@amritk/mjst 0.7.3 → 0.7.5

package/dist/combine-files.d.ts

@@ -11,3 +11,4 @@ import type { GeneratedFile } from '@amritk/generate-parsers';
  * type-only relative imports (no runtime helpers).
  */
 export declare const combineGeneratedFiles: (files: readonly GeneratedFile[]) => string;
+//# sourceMappingURL=combine-files.d.ts.map

package/dist/combine-files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"combine-files.d.ts","sourceRoot":"","sources":["../src/combine-files.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAA;AAO7D;;;;;;;;;;GAUG;AACH,eAAO,MAAM,qBAAqB,UAAW,SAAS,aAAa,EAAE,KAAG,MAwBvE,CAAA"}

package/dist/combine-files.js

@@ -0,0 +1,39 @@
+// Require whitespace after `import` so a property literally named `import` (e.g.
+// `import?: string`) is not mistaken for an import statement.
+const IMPORT_RE = /^import\s/;
+const RELATIVE_IMPORT_RE = /\bfrom\s+['"]\.\.?\//;
+/**
+ * Merges the per-schema {@link GeneratedFile}s into a single self-contained
+ * TypeScript module. Each generated file imports its sibling definitions via
+ * relative paths; since everything now lives in one file those imports are
+ * dropped, while any external (package) imports are hoisted to the top and
+ * deduplicated. The `index.ts` barrel is skipped because it only re-exports the
+ * declarations that are already inlined here.
+ *
+ * Intended for types-only output, where files contain only type definitions and
+ * type-only relative imports (no runtime helpers).
+ */
+export const combineGeneratedFiles = (files) => {
+    const externalImports = new Set();
+    const bodies = [];
+    for (const file of files) {
+        if (file.filename === 'index.ts')
+            continue;
+        const bodyLines = [];
+        for (const line of file.content.split('\n')) {
+            if (IMPORT_RE.test(line.trimStart())) {
+                // Relative imports point at sibling files that are now inlined — drop them.
+                if (RELATIVE_IMPORT_RE.test(line))
+                    continue;
+                externalImports.add(line.trim());
+                continue;
+            }
+            bodyLines.push(line);
+        }
+        const body = bodyLines.join('\n').trim();
+        if (body)
+            bodies.push(body);
+    }
+    const importBlock = [...externalImports].sort().join('\n');
+    return [importBlock, bodies.join('\n\n')].filter(Boolean).join('\n\n') + '\n';
+};

package/dist/detect-helpers-mode.d.ts

@@ -7,4 +7,5 @@
  * when the helper sources need to be shipped alongside the generated files
  * for the output to be self-contained.
  */
-export declare const detectHelpersMode: (outputDir: string) => "package" | "embedded";
+export declare const detectHelpersMode: (outputDir: string) => 'package' | 'embedded';
+//# sourceMappingURL=detect-helpers-mode.d.ts.map

package/dist/detect-helpers-mode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect-helpers-mode.d.ts","sourceRoot":"","sources":["../src/detect-helpers-mode.ts"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,cAAe,MAAM,KAAG,SAAS,GAAG,UAQjE,CAAA"}

package/dist/detect-helpers-mode.js

@@ -0,0 +1,21 @@
+import { createRequire } from 'node:module';
+import { resolve } from 'node:path';
+/**
+ * Detects whether `@amritk/helpers` is resolvable from the consumer's output
+ * directory using standard Node module resolution (walks up `node_modules`).
+ *
+ * Returns `'package'` when generated parsers can safely
+ * `import { ... } from '@amritk/helpers/...'` at runtime, or `'embedded'`
+ * when the helper sources need to be shipped alongside the generated files
+ * for the output to be self-contained.
+ */
+export const detectHelpersMode = (outputDir) => {
+    const req = createRequire(resolve(outputDir, 'noop.js'));
+    try {
+        req.resolve('@amritk/helpers/is-object');
+        return 'package';
+    }
+    catch {
+        return 'embedded';
+    }
+};

package/dist/load-config.d.ts

@@ -1,6 +1,7 @@
-import type { CliConfig } from './cli-config';
+import type { CliConfig } from './cli-config.js';
 /**
  * Loads a JSON config file and returns the relevant CLI config properties.
  * The config file should have the same keys as the CLI flags (schema, outDir).
  */
 export declare const loadConfig: (configPath: string) => Promise<Partial<CliConfig>>;
+//# sourceMappingURL=load-config.d.ts.map

package/dist/load-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-config.d.ts","sourceRoot":"","sources":["../src/load-config.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAO7C;;;GAGG;AACH,eAAO,MAAM,UAAU,eAAsB,MAAM,KAAG,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC,CAwB/E,CAAA"}

package/dist/load-config.js

@@ -0,0 +1,30 @@
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+const SOURCE_FORMATS = ['json', 'typebox', 'zod', 'valibot', 'effect'];
+const isSourceFormat = (value) => typeof value === 'string' && SOURCE_FORMATS.includes(value);
+/**
+ * Loads a JSON config file and returns the relevant CLI config properties.
+ * The config file should have the same keys as the CLI flags (schema, outDir).
+ */
+export const loadConfig = async (configPath) => {
+    const absolutePath = resolve(configPath);
+    const raw = await readFile(absolutePath, 'utf-8');
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        throw new Error(`Config file must be a JSON object: ${configPath}`);
+    }
+    const obj = parsed;
+    return {
+        ...(typeof obj['schema'] === 'string' && { schema: obj['schema'] }),
+        ...(typeof obj['schemaDir'] === 'string' && { schemaDir: obj['schemaDir'] }),
+        ...(typeof obj['outDir'] === 'string' && { outDir: obj['outDir'] }),
+        ...(typeof obj['outFile'] === 'string' && { outFile: obj['outFile'] }),
+        ...(isSourceFormat(obj['input']) && { input: obj['input'] }),
+        ...(typeof obj['export'] === 'string' && { export: obj['export'] }),
+        ...(typeof obj['typesOnly'] === 'boolean' && { typesOnly: obj['typesOnly'] }),
+        ...(typeof obj['build'] === 'boolean' && { build: obj['build'] }),
+        ...(typeof obj['logWarnings'] === 'boolean' && { logWarnings: obj['logWarnings'] }),
+        ...(typeof obj['strict'] === 'boolean' && { strict: obj['strict'] }),
+        ...(typeof obj['readonly'] === 'boolean' && { readonly: obj['readonly'] }),
+    };
+};

package/dist/load-schema-module.d.ts

@@ -14,3 +14,4 @@
  * for a `.ts` path so the cause is not a cryptic module-resolution error.
  */
 export declare const loadSchemaModule: (modulePath: string, exportName?: string) => Promise<unknown>;
+//# sourceMappingURL=load-schema-module.d.ts.map

package/dist/load-schema-module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-schema-module.d.ts","sourceRoot":"","sources":["../src/load-schema-module.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB,eAAsB,MAAM,eAAe,MAAM,KAAG,OAAO,CAAC,OAAO,CAkC/F,CAAA"}

package/dist/load-schema-module.js

@@ -0,0 +1,45 @@
+import { pathToFileURL } from 'node:url';
+/**
+ * Loads a schema authored as a JS/TS module and returns the exported schema value.
+ *
+ * Export selection, in order of preference:
+ * 1. The export named by `exportName`, when provided (`--export <name>`).
+ * 2. The module's default export.
+ * 3. The sole named export, when there is exactly one.
+ *
+ * Anything else is ambiguous and throws, so the user can disambiguate explicitly
+ * rather than have mjst guess wrong.
+ *
+ * Importing a `.ts` module requires a TypeScript-capable runtime (Bun, or Node
+ * with a loader such as `tsx`). We surface a friendly hint when the import fails
+ * for a `.ts` path so the cause is not a cryptic module-resolution error.
+ */
+export const loadSchemaModule = async (modulePath, exportName) => {
+    let mod;
+    try {
+        mod = (await import(pathToFileURL(modulePath).href));
+    }
+    catch (error) {
+        const hint = modulePath.endsWith('.ts')
+            ? ' Importing a .ts schema requires a TypeScript-capable runtime — run mjst via `bunx`, or install `tsx` and run Node with `--import tsx`.'
+            : '';
+        throw new Error(`Failed to load schema module at ${modulePath}.${hint}\n${String(error)}`);
+    }
+    if (exportName) {
+        if (!(exportName in mod)) {
+            throw new Error(`Schema module ${modulePath} has no export named '${exportName}'.`);
+        }
+        return mod[exportName];
+    }
+    if ('default' in mod && mod['default'] !== undefined) {
+        return mod['default'];
+    }
+    const namedKeys = Object.keys(mod).filter((key) => key !== 'default');
+    if (namedKeys.length === 1) {
+        const key = namedKeys[0];
+        if (key)
+            return mod[key];
+    }
+    throw new Error(`Schema module ${modulePath} exports ${namedKeys.length} values (${namedKeys.join(', ') || 'none'}). ` +
+        `Specify which one to use with --export <name>.`);
+};

package/dist/parse-cli-args.d.ts

@@ -1,4 +1,4 @@
-import type { CliConfig } from './cli-config';
+import type { CliConfig } from './cli-config.js';
 /**
  * Parses command-line arguments into a partial CLI config.
  * Every flag accepts both kebab-case and camelCase (e.g. `--out-dir` and `--outDir`)
@@ -7,3 +7,4 @@ import type { CliConfig } from './cli-config';
  * provided are returned so they can be layered on top of config file values.
  */
 export declare const parseCliArgs: (args: readonly string[]) => Partial<CliConfig>;
+//# sourceMappingURL=parse-cli-args.d.ts.map

package/dist/parse-cli-args.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-cli-args.d.ts","sourceRoot":"","sources":["../src/parse-cli-args.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AA0G7C;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,SAAU,SAAS,MAAM,EAAE,KAAG,OAAO,CAAC,SAAS,CA0DvE,CAAA"}

package/dist/parse-cli-args.js

@@ -0,0 +1,142 @@
+const SOURCE_FORMATS = ['json', 'typebox', 'zod', 'valibot', 'effect'];
+// Boolean flags toggle on by presence and accept `--flag=false` to opt out.
+const BOOLEAN_KEYS = new Set(['typesOnly', 'build', 'logWarnings', 'strict', 'readonly']);
+// Value flags consume the following argument (or `--flag=value`).
+const VALUE_KEYS = new Set([
+    'schema',
+    'schemaDir',
+    'outDir',
+    'outFile',
+    'input',
+    'export',
+    'helpers',
+    'typeSuffix',
+]);
+/** Normalizes a CLI flag name to its camelCase config key so both `--out-dir` and `--outDir` map to `outDir`. */
+const toCamelCase = (key) => key.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+const parseHelpersValue = (value) => {
+    if (value === 'package' || value === 'embedded')
+        return value;
+    return undefined;
+};
+const parseInputValue = (value) => SOURCE_FORMATS.includes(value) ? value : undefined;
+/** Assigns a value-flag onto the config. Returns false for unknown keys. */
+const assignValue = (config, key, value) => {
+    switch (key) {
+        case 'schema':
+            config.schema = value;
+            return true;
+        case 'schemaDir':
+            config.schemaDir = value;
+            return true;
+        case 'outDir':
+            config.outDir = value;
+            return true;
+        case 'outFile':
+            config.outFile = value;
+            return true;
+        case 'export':
+            config.export = value;
+            return true;
+        case 'typeSuffix':
+            config.typeSuffix = value;
+            return true;
+        case 'input': {
+            const parsed = parseInputValue(value);
+            if (parsed)
+                config.input = parsed;
+            return true;
+        }
+        case 'helpers': {
+            const parsed = parseHelpersValue(value);
+            if (parsed)
+                config.helpers = parsed;
+            return true;
+        }
+        default:
+            return false;
+    }
+};
+/** Assigns a boolean flag onto the config. Returns false for unknown keys. */
+const assignBoolean = (config, key, value) => {
+    switch (key) {
+        case 'typesOnly':
+            config.typesOnly = value;
+            return true;
+        case 'build':
+            config.build = value;
+            return true;
+        case 'logWarnings':
+            config.logWarnings = value;
+            return true;
+        case 'strict':
+            config.strict = value;
+            return true;
+        case 'readonly':
+            config.readonly = value;
+            return true;
+        default:
+            return false;
+    }
+};
+/**
+ * Parses command-line arguments into a partial CLI config.
+ * Every flag accepts both kebab-case and camelCase (e.g. `--out-dir` and `--outDir`)
+ * and supports either `--flag value` or `--flag=value` syntax. Boolean flags toggle
+ * on by presence and accept `--flag=false` to opt out. Only flags that were explicitly
+ * provided are returned so they can be layered on top of config file values.
+ */
+export const parseCliArgs = (args) => {
+    const config = {};
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (!arg || !arg.startsWith('--')) {
+            continue;
+        }
+        // Handle --flag=value syntax
+        const equalsIndex = arg.indexOf('=');
+        if (equalsIndex !== -1) {
+            const key = toCamelCase(arg.slice(2, equalsIndex));
+            const value = arg.slice(equalsIndex + 1);
+            if (key === 'banner') {
+                // --banner=false → false, --banner=true → true, --banner=<text> → custom string
+                config.banner = value === 'false' ? false : value === 'true' ? true : value;
+            }
+            else if (BOOLEAN_KEYS.has(key)) {
+                assignBoolean(config, key, value !== 'false');
+            }
+            else {
+                assignValue(config, key, value);
+            }
+            continue;
+        }
+        const key = toCamelCase(arg.slice(2));
+        // --banner: presence alone enables the default message; an immediately
+        // following non-flag argument is treated as a custom message string.
+        if (key === 'banner') {
+            const nextArg = args[i + 1];
+            if (nextArg && !nextArg.startsWith('--')) {
+                config.banner = nextArg;
+                i++;
+            }
+            else {
+                config.banner = true;
+            }
+            continue;
+        }
+        // Boolean flag: presence alone enables it, no value needed
+        if (BOOLEAN_KEYS.has(key)) {
+            assignBoolean(config, key, true);
+            continue;
+        }
+        // Value flag: consume the next argument when it is not another flag
+        if (VALUE_KEYS.has(key)) {
+            const value = args[i + 1];
+            if (value && !value.startsWith('--')) {
+                assignValue(config, key, value);
+                i++;
+            }
+        }
+    }
+    return config;
+};

package/dist/read-version.d.ts

@@ -6,3 +6,4 @@
  * sits one directory above both.
  */
 export declare const readVersion: () => Promise<string>;
+//# sourceMappingURL=read-version.d.ts.map

package/dist/read-version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-version.d.ts","sourceRoot":"","sources":["../src/read-version.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,QAAa,OAAO,CAAC,MAAM,CAIlD,CAAA"}

package/dist/read-version.js

@@ -0,0 +1,13 @@
+import { readFile } from 'node:fs/promises';
+/**
+ * Reads the CLI's own version from its `package.json`.
+ *
+ * Resolved relative to this module so it works whether the code runs from
+ * `src/` (dev) or the bundled `dist/cli.js` (published) — `package.json`
+ * sits one directory above both.
+ */
+export const readVersion = async () => {
+    const pkgUrl = new URL('../package.json', import.meta.url);
+    const pkg = JSON.parse(await readFile(pkgUrl, 'utf-8'));
+    return pkg.version ?? '0.0.0';
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/mjst",
-  "version": "0.7.3",
+  "version": "0.7.5",
   "description": "Generate TypeScript parsers and type definitions from JSON Schemas.",
   "type": "module",
   "license": "MIT",
@@ -36,16 +36,16 @@
   "scripts": {
     "dev": "bun run --conditions=development ./src/cli.ts",
     "start": "bun run ./src/cli.ts",
-    "build": "bun run build:code && bun run build:types",
-    "build:code": "bun build ./src/cli.ts --outdir=dist --target=node",
-    "build:types": "tsc -p .",
+    "build": "tsgo -p tsconfig.build.json && tsc-alias -p tsconfig.build.json -f",
+    "types:check": "tsgo -p . --noEmit",
+    "test": "NODE_ENV=production vitest run --root ../.. cli",
     "generate-readme": "bun run ./scripts/generate-readme.ts"
   },
   "dependencies": {
-    "@amritk/adapters": "0.2.5",
-    "@amritk/generate-parsers": "0.6.3",
-    "@amritk/generate-markdown": "0.2.3",
-    "@amritk/helpers": "0.6.2"
+    "@amritk/adapters": "0.2.7",
+    "@amritk/generate-parsers": "0.7.1",
+    "@amritk/generate-markdown": "0.2.4",
+    "@amritk/helpers": "0.7.1"
   },
   "devDependencies": {
     "json-schema-typed": "^8.0.1"