dependabot[bot] a69c885fa8 build(deps): Bump actions/checkout from 6 to 7 (#114)
Bumps [actions/checkout](https://github.com/actions/checkout) from 6 to 7.
- [Release notes](https://github.com/actions/checkout/releases)
- [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md)
- [Commits](https://github.com/actions/checkout/compare/v6...v7)

---
updated-dependencies:
- dependency-name: actions/checkout
  dependency-version: '7'
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
2026-06-22 13:09:37 +07:00
2026-05-13 09:43:37 +07:00
2026-05-13 09:43:37 +07:00
2026-05-13 09:43:37 +07:00
2026-05-13 09:43:37 +07:00
2026-05-13 09:43:37 +07:00
2026-05-13 09:43:37 +07:00
2026-05-13 09:43:37 +07:00
2026-05-13 09:43:37 +07:00

JSONPrism

Disperse JSON into many formats.

One JSON input. Multi-target formats. Fully in your browser.

CI Deploy License: Apache 2.0

Live demo · Tiếng Việt · Roadmap


JSONPrism is a refracting tool for developers. It takes a single JSON input and disperses it into many target formats — like white light through a prism. Everything runs client-side, so your data never leaves your device.

Target formats

Format Extension Status Reverse (→ JSON)
JSONL .jsonl ✅ Phase 1 ✅
CSV .csv ✅ Phase 1 ✅
TSV .tsv ✅ Phase 1 ✅
YAML .yaml ✅ Phase 1 ✅
XML .xml ✅ Phase 2 —
TOML .toml ✅ Phase 2 ✅
Markdown table .md ✅ Phase 2 —
SQL INSERT .sql ✅ Phase 2 —
RESX (.NET) .resx ✅ Phase 3 ✅
BSON .bson ✅ Phase 4 —
CBOR .cbor ✅ Phase 4 —
MessagePack .msgpack ✅ Phase 4 —

Features

  • Client-side only — no server, no telemetry, no upload. Your JSON stays in your browser.
  • Fast first paint — routes and the CodeMirror editor are lazy-loaded, and vendor/parser code is split into small per-feature chunks, so the browser only downloads what you actually use.
  • Batch processing — up to 500 files at once (Phase 2).
  • Smart shape detection — recognizes flat objects, arrays of objects, scalars; suggests the best target format.
  • Per-format options — pretty-print, indentation, dialect (for SQL), alignment (for Markdown), and more.
  • Dark + light themes — Prism Spectrum palette with violet / cyan / amber / rose accents.
  • Responsive — designed for viewports ≥ 360 × 640. Smaller screens still work but may feel cramped; on mobile, Input and Output use a Tabs UI to give each panel full height. See docs/tested-viewports.md for the full device test matrix.
  • EN + VI — bilingual interface out of the box. More languages welcome.
  • Tauri desktop build — drag-and-drop file workflow, offline-first (Phase 2 milestone).

Tech stack

  • Vite 8 + React 19 + TypeScript 5.7
  • Tailwind CSS v4 + shadcn/ui (New York style, neutral base)
  • CodeMirror 6 for the input editor (Phase 1 polish)
  • PapaParse, js-yaml, smol-toml, fast-xml-parser for parsing/serialization
  • i18next for translations, Zustand for state, Sonner for toasts
  • Tauri 2 wrapper (Phase 2)

Quick start

Requirements: Node.js 22 LTS or newer.

git clone https://github.com/poli0981/jsonPrism.git
cd jsonprism
npm install
npm run dev          # http://localhost:5173

Desktop app (Tauri 2)

JSONPrism also ships as a native desktop app via Tauri 2. The app uses the same React UI, with native OS dialogs and drag-drop hooked into the existing batch flow.

Additional requirements:

  • Rust toolchain (rustup) with the stable channel
  • Platform build deps:
    • Windows: Visual Studio Build Tools (C++ workload) + WebView2 (preinstalled on Windows 11)
    • macOS: Xcode Command Line Tools (xcode-select --install)
    • Linux: libwebkit2gtk-4.1-dev, libappindicator3-dev, librsvg2-dev, patchelf, libssl-dev

Generate icons once (uses Tauri's CLI to render the SVG to PNG/ICO/ICNS):

npm run tauri:icon

Run in dev mode (Vite + Tauri window with hot reload):

npm run tauri:dev

Build native bundles:

npm run tauri:build

Output:

  • Windows → src-tauri/target/release/bundle/msi/*.msi + nsis/*-setup.exe
  • macOS → src-tauri/target/release/bundle/dmg/*.dmg + macos/*.app
  • Linux → src-tauri/target/release/bundle/appimage/*.AppImage + deb/*.deb

Automated releases: pushing a v* tag triggers .github/workflows/release.yml, which builds for all platforms in parallel and creates a draft GitHub release.

Android app (Tauri 2)

JSONPrism also ships as an Android app you sideload from a .apk. Same React UI; native file picker via the dialog plugin. Requires Android 12 (API 31) or newer — the OS refuses to install it on older versions.

System requirements

Requirement Detail
Android version 12 (API 31) or newer — older versions are blocked at install time (INSTALL_FAILED_OLDER_SDK)
System WebView Chromium 111+ (Android System WebView / Chrome). Kept current by the Play Store on most devices; a much older WebView renders the layout incorrectly — update "Android System WebView" and Chrome from the Play Store if the UI looks broken.
CPU / ABI arm64-v8a, armeabi-v7a, x86, or x86_64 — the single universal APK runs on all of them (modern phones are arm64-v8a)
RAM 2 GB minimum; 4 GB recommended for large or batch (up to 500 files) conversions
Storage ~27 MB to download; ~100 MB free recommended (install + temporary working files)
Network None — the app runs fully offline and sends nothing off the device

Install (users)

  1. Download JSONPrism-<version>-android-universal.apk from the Releases page.
  2. Open it; Android will ask you to allow "install unknown apps" for your browser/file manager — enable it, then install.
  3. Needs Android 12+. The app runs fully offline.

Build (developers)

Additional requirements (on top of the desktop Rust toolchain):

  • Android Studio with SDK Platform 31+, Build-Tools, Platform-Tools, Command-line Tools, and an NDK
  • JDK — the JBR bundled with Android Studio is fine
  • Environment variables: JAVA_HOME, ANDROID_HOME, NDK_HOME (see docs/TAURI-NOTES.md)
  • Rust Android targets: rustup target add aarch64-linux-android armv7-linux-androideabi i686-linux-android x86_64-linux-android

The Android Gradle project lives in src-tauri/gen/android/ and is committed. You do not need to run tauri android init for a normal build.

Run on a device/emulator (Android 12+):

npm run tauri:android:dev

Build a universal release APK:

npm run tauri:android:build

Output: src-tauri/gen/android/app/build/outputs/apk/universal/release/app-universal-release.apk. Release signing is read from src-tauri/gen/android/keystore.properties (gitignored); without it the APK builds unsigned. See docs/TAURI-NOTES.md for keystore setup and the CI signing secrets.

Automated releases: the same v* tag also runs the android job in release.yml, which signs the APK with the keystore from repository secrets and attaches it to the draft release.

Scripts

Script What it does
npm run dev Start Vite dev server with HMR
npm run build Production build to dist/
npm run preview Preview the built site locally
npm run lint Run ESLint
npm run lint:fix Run ESLint with autofix
npm run typecheck TypeScript type-check, no emit
npm run format Format with Prettier
npm run format:check Check formatting (CI uses this)

shadcn/ui components

The components.json is preconfigured. Add components on demand:

npx shadcn@latest add button input textarea tabs select card dialog sheet \
  dropdown-menu switch badge progress tooltip sonner resizable

Architecture

src/
├── app/                 # Router + global providers
├── components/
│   ├── ui/              # shadcn components (added on demand)
│   ├── layout/          # Header, Footer, ThemeToggle
│   ├── converter/       # Workspace, panels, format picker
│   └── common/          # ErrorBoundary, LanguageSwitcher
├── converters/          # One module per target format
│   ├── types.ts         # Converter interface
│   ├── registry.ts      # Lookup table
│   └── *.ts             # Per-format implementations
├── hooks/               # Custom hooks
├── i18n/                # Translations (en, vi)
├── lib/                 # detect, theme, utils, sample
├── pages/               # Home, About
├── styles/              # globals.css (Tailwind + theme tokens)
└── main.tsx

Adding a new format

Each format is a self-contained module implementing the Converter interface:

import type { Converter } from './types';

interface MyFormatOptions {
  indent: 2 | 4;
}

export const myFormatConverter: Converter<MyFormatOptions> = {
  meta: {
    id: 'myformat',
    labelKey: 'formats.myformat',
    extension: 'myf',
    mimeType: 'application/x-myformat',
    phase: 1,
    ready: true,
  },
  defaultOptions: { indent: 2 },
  convert({ data }, options) {
    try {
      const output = serialize(data, options);
      return { ok: true, output };
    } catch (err) {
      return { ok: false, error: (err as Error).message };
    }
  },
};

Then register it in src/converters/registry.ts and add label keys to src/i18n/locales/*.json.

See docs/ROADMAP.md for the full phase plan.

Contributing

Pull requests welcome — please read CONTRIBUTING.md first. PRs that match the auto-ignored patterns described there (suspicious code, off-topic preamble, no description, etc.) get closed without review.

For bug reports and feature requests, use GitHub Issues. For security vulnerabilities, use the private Security Advisory flow.

Project docs

Doc What's in it
PRIVACY.md Offline-first, localStorage-only, no telemetry.
TERMS.md ToS / EULA — acceptable use, license inheritance, user data ownership.
SECURITY.md How to report vulnerabilities; response SLAs.
DISCLAIMER.md One-person + AI-assisted project; no warranty.
THIRD-PARTY.md Every dependency: version, license, link.
MAINTAINERS.md Who's responsible for what.
CODE_OF_CONDUCT.md Contributor Covenant v2.1.
docs/ROADMAP.md Phase plan, current status.
docs/pc_spec.md · docs/dev_env.md Maintainer's hardware + toolchain.
docs/TAURI-NOTES.md Tauri build / process notes.
docs/RESX-MIGRATION.md i18next JSON → .NET RESX tutorial.

Community

Hang out, ask questions, or follow updates:

Acknowledgements

Substantial parts of JSONPrism's code, tests, translations, and docs were drafted with Claude Chat and Claude Code (Opus 4.7, 1M context). See DISCLAIMER.md for the full AI-assist disclosure. Translation quality for non-English locales is best-effort and contributions from native speakers are welcomed.

Sponsorship

If JSONPrism is useful to you, consider sponsoring the maintainer via any of the channels in .github/FUNDING.yml: GitHub Sponsors, Ko-fi, Buy Me a Coffee, Patreon, or PayPal.

License

Apache License 2.0 — © 2026 Kokone (@poli0981).

S
Description
No description provided
Readme Apache-2.0
1.2 MiB
0 Stars 1 Watchers 0 Forks
Languages
TypeScript 96.4%
CSS 1.5%
Kotlin 0.7%
HTML 0.6%
Rust 0.4%
Other 0.4%