@amritk/mjst 0.12.2 → 0.12.3

package/dist/combine-files.js

@@ -1,39 +1,28 @@
-// 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 combineGeneratedFiles = (files) => {
+  const externalImports = /* @__PURE__ */ 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())) {
+        if (RELATIVE_IMPORT_RE.test(line))
+          continue;
+        externalImports.add(line.trim());
+        continue;
+      }
+      bodyLines.push(line);
     }
-    const importBlock = [...externalImports].sort().join('\n');
-    return [importBlock, bodies.join('\n\n')].filter(Boolean).join('\n\n') + '\n';
+    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";
+};
+export {
+  combineGeneratedFiles
 };

package/dist/detect-helpers-mode.js

@@ -1,45 +1,32 @@
-import { readFileSync } from 'node:fs';
-import { dirname, join, parse as parsePath, resolve } from 'node:path';
-/** Reads a package.json's declared dependency names, or `undefined` if unreadable. */
+import { readFileSync } from "node:fs";
+import { dirname, join, parse as parsePath, resolve } from "node:path";
 const readDeclaredDeps = (packageJsonPath) => {
-    try {
-        const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
-        return new Set([
-            ...Object.keys(pkg.dependencies ?? {}),
-            ...Object.keys(pkg.devDependencies ?? {}),
-            ...Object.keys(pkg.peerDependencies ?? {}),
-            ...Object.keys(pkg.optionalDependencies ?? {}),
-        ]);
-    }
-    catch {
-        return undefined;
-    }
+  try {
+    const pkg = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    return /* @__PURE__ */ new Set([
+      ...Object.keys(pkg.dependencies ?? {}),
+      ...Object.keys(pkg.devDependencies ?? {}),
+      ...Object.keys(pkg.peerDependencies ?? {}),
+      ...Object.keys(pkg.optionalDependencies ?? {})
+    ]);
+  } catch {
+    return void 0;
+  }
 };
-/**
- * Detects whether generated parsers should import `@amritk/helpers` from the
- * package (`'package'`) or ship the helper sources alongside them (`'embedded'`).
- *
- * We select `'package'` only when `@amritk/helpers` is a *declared* dependency
- * (dependencies / devDependencies / peer / optional) of the target project's
- * nearest `package.json` above `outputDir`. Merely being *resolvable* is not
- * enough: under npm/bun's hoisted layouts `@amritk/helpers` can sit in
- * `node_modules` purely as a transitive dependency of `@amritk/mjst`, which
- * makes `import '@amritk/helpers/...'` work locally but break under
- * pnpm/isolated installs where undeclared packages are not reachable. Requiring
- * a declaration keeps auto-detected `'package'` output portable across install
- * layouts; everything else falls back to the self-contained `'embedded'` mode.
- */
-export const detectHelpersMode = (outputDir) => {
-    let dir = resolve(outputDir);
-    const { root } = parsePath(dir);
-    while (true) {
-        const declared = readDeclaredDeps(join(dir, 'package.json'));
-        if (declared) {
-            return declared.has('@amritk/helpers') ? 'package' : 'embedded';
-        }
-        if (dir === root)
-            break;
-        dir = dirname(dir);
+const detectHelpersMode = (outputDir) => {
+  let dir = resolve(outputDir);
+  const { root } = parsePath(dir);
+  while (true) {
+    const declared = readDeclaredDeps(join(dir, "package.json"));
+    if (declared) {
+      return declared.has("@amritk/helpers") ? "package" : "embedded";
     }
-    return 'embedded';
+    if (dir === root)
+      break;
+    dir = dirname(dir);
+  }
+  return "embedded";
+};
+export {
+  detectHelpersMode
 };

package/dist/emit-examples.js

@@ -1,29 +1,19 @@
-import { mkdir, writeFile } from 'node:fs/promises';
-import { dirname, join, relative } from 'node:path';
-import { buildExampleSchema } from '@amritk/generate-examples';
-/**
- * Emits fast-check arbitrary + concrete example files for one schema into an
- * `examples/` subdirectory of `outputDir`.
- *
- * The dedicated subdirectory keeps the test-data output from colliding with the
- * parser files, which otherwise share the same `<name>.ts` / `index.ts` names.
- * Each generated file exports a `FooArbitrary` (a `fast-check` arbitrary that
- * produces schema-valid values) and a static `fooExample` value; an `index.ts`
- * barrel re-exports them. The arbitraries import `fast-check`, which consumers
- * must install as a (dev) dependency.
- *
- * @returns The written file paths, relative to `outputDir`.
- */
-export const emitExamples = async (options) => {
-    const { schema, rootTypeName, outputDir, subDir = '', typeSuffix, bannerPrefix = '' } = options;
-    const files = await buildExampleSchema(schema, rootTypeName, typeSuffix);
-    const exampleDir = join(outputDir, 'examples', subDir);
-    const written = [];
-    for (const file of files) {
-        const filePath = join(exampleDir, file.filename);
-        await mkdir(dirname(filePath), { recursive: true });
-        await writeFile(filePath, bannerPrefix + file.content, 'utf-8');
-        written.push(relative(outputDir, filePath));
-    }
-    return written;
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, join, relative } from "node:path";
+import { buildExampleSchema } from "@amritk/generate-examples";
+const emitExamples = async (options) => {
+  const { schema, rootTypeName, outputDir, subDir = "", typeSuffix, bannerPrefix = "" } = options;
+  const files = await buildExampleSchema(schema, rootTypeName, typeSuffix);
+  const exampleDir = join(outputDir, "examples", subDir);
+  const written = [];
+  for (const file of files) {
+    const filePath = join(exampleDir, file.filename);
+    await mkdir(dirname(filePath), { recursive: true });
+    await writeFile(filePath, bannerPrefix + file.content, "utf-8");
+    written.push(relative(outputDir, filePath));
+  }
+  return written;
+};
+export {
+  emitExamples
 };

package/dist/has-external-refs.js

@@ -1,22 +1,17 @@
-/** The reference keywords whose value may point at another document (a non-`#` target). */
-const REF_KEYWORDS = ['$ref', '$dynamicRef', '$recursiveRef'];
-/**
- * Whether `data` contains a reference into another document (a `$ref` value that
- * is not a same-document `#...` fragment). Same-document references resolve
- * without a disk round-trip, so callers can skip the file-backed resolver — and
- * preserve behavior that depends on those internal refs — unless an external
- * (cross-file or remote) target exists.
- */
-export const hasExternalRefs = (data) => {
-    if (data === null || typeof data !== 'object')
-        return false;
-    if (Array.isArray(data))
-        return data.some(hasExternalRefs);
-    const obj = data;
-    for (const keyword of REF_KEYWORDS) {
-        const value = obj[keyword];
-        if (typeof value === 'string' && !value.startsWith('#'))
-            return true;
-    }
-    return Object.values(obj).some(hasExternalRefs);
+const REF_KEYWORDS = ["$ref", "$dynamicRef", "$recursiveRef"];
+const hasExternalRefs = (data) => {
+  if (data === null || typeof data !== "object")
+    return false;
+  if (Array.isArray(data))
+    return data.some(hasExternalRefs);
+  const obj = data;
+  for (const keyword of REF_KEYWORDS) {
+    const value = obj[keyword];
+    if (typeof value === "string" && !value.startsWith("#"))
+      return true;
+  }
+  return Object.values(obj).some(hasExternalRefs);
+};
+export {
+  hasExternalRefs
 };

package/dist/help-text.js

@@ -1,10 +1,4 @@
-/**
- * Usage text printed for `--help`/`-h` and when the CLI is invoked with no
- * arguments. Kept as a hand-written constant because the config schema that
- * documents these flags (config.schema.json) is not shipped in the published
- * package; the help-text test cross-checks that every flag is listed.
- */
-export const HELP_TEXT = `mjst — generate TypeScript parsers and type definitions from JSON Schemas
+const HELP_TEXT = `mjst \u2014 generate TypeScript parsers and type definitions from JSON Schemas
 
 Usage:
   mjst --schema <path> --out-dir <dir> [options]
@@ -49,3 +43,6 @@ Misc:
 
 Docs: https://github.com/amritk/mjst/tree/main/packages/cli#readme
 `;
+export {
+  HELP_TEXT
+};

package/dist/lint/resolver.js

@@ -1,126 +1,93 @@
-import { readFileSync } from 'node:fs';
-import { resolve as resolvePath } from 'node:path';
-import { createDocument, DiagnosticSeverity, resolveSourceOriginFromMap, } from '@amritk/lint';
-import { resolveRefs, resolveRefsFromFile } from '@amritk/resolve-refs';
-import { parse as parseYaml } from '@amritk/yaml';
-import { hasExternalRefs } from '../has-external-refs.js';
+import { readFileSync } from "node:fs";
+import { resolve as resolvePath } from "node:path";
+import { createDocument, DiagnosticSeverity, resolveSourceOriginFromMap } from "@amritk/lint";
+import { resolveRefs, resolveRefsFromFile } from "@amritk/resolve-refs";
+import { parse as parseYaml } from "@amritk/yaml";
+import { hasExternalRefs } from "../has-external-refs.js";
 const isRemote = (location) => /^https?:\/\//i.test(location);
-/**
- * Parses a referenced document by extension: YAML for `.yaml`/`.yml`, JSON for
- * `.json`, and for anything else (extensionless, remote) tries JSON first, then
- * YAML. YAML is a JSON superset, so this accepts every document the linter does.
- */
 const parseDoc = (content, location) => {
-    if (/\.ya?ml$/i.test(location))
-        return parseYaml(content);
-    if (/\.json$/i.test(location))
-        return JSON.parse(content);
-    try {
-        return JSON.parse(content);
-    }
-    catch {
-        return parseYaml(content);
-    }
+  if (/\.ya?ml$/i.test(location))
+    return parseYaml(content);
+  if (/\.json$/i.test(location))
+    return JSON.parse(content);
+  try {
+    return JSON.parse(content);
+  } catch {
+    return parseYaml(content);
+  }
 };
-/** Whether the file at `absolute` reads back byte-for-byte as `input` (the document we linted). */
 const readsBackAs = (absolute, input) => {
-    try {
-        return readFileSync(absolute, 'utf8') === input;
-    }
-    catch {
-        return false;
-    }
+  try {
+    return readFileSync(absolute, "utf8") === input;
+  } catch {
+    return false;
+  }
 };
-/**
- * Builds the {@link ISourceSet} the runner uses to map a finding on a resolved
- * (dereferenced) node back to the file it came from. Origins from the resolver
- * attribute each inlined node to its source document + path; `get` lazily parses
- * each source file (with a position map) so findings on cross-file nodes report
- * that file's own `line:column`. The root document is already parsed by the
- * linter, so it is reused directly. Remote documents are not re-fetched here, so
- * a finding inlined from a URL falls back to the root document's position.
- */
 const buildSourceSet = (rootDocument, resolved, origins, rootLocation) => {
-    const documents = new Map([[rootLocation, rootDocument]]);
-    const originMap = origins ?? new Map();
-    const load = (location) => {
-        if (documents.has(location))
-            return documents.get(location);
-        let document;
-        if (location !== '' && !isRemote(location)) {
-            try {
-                document = createDocument(readFileSync(location, 'utf8'), { source: location });
-            }
-            catch {
-                document = undefined;
-            }
-        }
-        documents.set(location, document);
-        return document;
-    };
-    return {
-        get: load,
-        origin: (path) => resolveSourceOriginFromMap(resolved, originMap, rootLocation, path),
-    };
+  const documents = /* @__PURE__ */ new Map([[rootLocation, rootDocument]]);
+  const originMap = origins ?? /* @__PURE__ */ new Map();
+  const load = (location) => {
+    if (documents.has(location))
+      return documents.get(location);
+    let document;
+    if (location !== "" && !isRemote(location)) {
+      try {
+        document = createDocument(readFileSync(location, "utf8"), { source: location });
+      } catch {
+        document = void 0;
+      }
+    }
+    documents.set(location, document);
+    return document;
+  };
+  return {
+    get: load,
+    origin: (path) => resolveSourceOriginFromMap(resolved, originMap, rootLocation, path)
+  };
 };
-/** A zero-width range at the document start, for resolve errors with no recoverable position. */
 const DOCUMENT_START = { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } };
-/**
- * Maps resolver failures ({@link ResolveError}) into lint findings so an
- * unresolvable `$ref` — a typo'd pointer, a missing file, a refused/failed
- * remote fetch — surfaces as a diagnostic instead of being silently dropped. An
- * error carrying a JSON path is anchored to that node's position in the root
- * document (best effort, `closest`); otherwise the finding is document-level.
- */
 const toFindings = (errors, root) => errors.map((error) => {
-    const location = error.path.length > 0 ? root.getLocationForJsonPath(error.path, true) : undefined;
-    const finding = {
-        code: 'unresolved-ref',
-        message: error.message,
-        path: error.path,
-        severity: DiagnosticSeverity.Error,
-        range: location?.range ?? DOCUMENT_START,
-    };
-    if (root.source !== undefined)
-        finding.source = root.source;
-    return finding;
+  const location = error.path.length > 0 ? root.getLocationForJsonPath(error.path, true) : void 0;
+  const finding = {
+    code: "unresolved-ref",
+    message: error.message,
+    path: error.path,
+    severity: DiagnosticSeverity.Error,
+    range: location?.range ?? DOCUMENT_START
+  };
+  if (root.source !== void 0)
+    finding.source = root.source;
+  return finding;
 });
-/**
- * Builds a {@link LintResolver} backed by `@amritk/resolve-refs`, dereferencing
- * `$ref`, `$dynamicRef`/`$dynamicAnchor`, and `$recursiveRef`/`$recursiveAnchor`
- * so rules with `resolved: true` (the ruleset default) see through references.
- *
- * Internal-only documents resolve in memory. A document with cross-file/remote
- * refs is resolved from disk **only when its source file reads back exactly as
- * the linted input** — so a piped document (`--stdin-filepath`) never resolves
- * against a different on-disk file — with remote fetching gated by `options`.
- */
-export const createLintResolver = (options = {}) => {
-    const fromFileOptions = {
-        remote: options.remote ?? false,
-        ...(options.allowedHosts ? { allowedHosts: options.allowedHosts } : {}),
-        ...(options.allowPrivateHosts ? { allowPrivateHosts: options.allowPrivateHosts } : {}),
-        parse: parseDoc,
-        trackOrigins: true,
-    };
-    return async (document, { input }) => {
-        const { source } = document;
-        if (source && hasExternalRefs(document.data)) {
-            const absolute = resolvePath(source);
-            if (readsBackAs(absolute, input)) {
-                const { resolved, origins, errors } = await resolveRefsFromFile(absolute, fromFileOptions);
-                return {
-                    resolved,
-                    sources: buildSourceSet(document, resolved, origins, absolute),
-                    ...(errors.length > 0 ? { diagnostics: toFindings(errors, document) } : {}),
-                };
-            }
-        }
-        const { resolved, origins, errors } = resolveRefs(document.data, { trackOrigins: true });
+const createLintResolver = (options = {}) => {
+  const fromFileOptions = {
+    remote: options.remote ?? false,
+    ...options.allowedHosts ? { allowedHosts: options.allowedHosts } : {},
+    ...options.allowPrivateHosts ? { allowPrivateHosts: options.allowPrivateHosts } : {},
+    parse: parseDoc,
+    trackOrigins: true
+  };
+  return async (document, { input }) => {
+    const { source } = document;
+    if (source && hasExternalRefs(document.data)) {
+      const absolute = resolvePath(source);
+      if (readsBackAs(absolute, input)) {
+        const { resolved: resolved2, origins: origins2, errors: errors2 } = await resolveRefsFromFile(absolute, fromFileOptions);
         return {
-            resolved,
-            sources: buildSourceSet(document, resolved, origins, ''),
-            ...(errors.length > 0 ? { diagnostics: toFindings(errors, document) } : {}),
+          resolved: resolved2,
+          sources: buildSourceSet(document, resolved2, origins2, absolute),
+          ...errors2.length > 0 ? { diagnostics: toFindings(errors2, document) } : {}
         };
+      }
+    }
+    const { resolved, origins, errors } = resolveRefs(document.data, { trackOrigins: true });
+    return {
+      resolved,
+      sources: buildSourceSet(document, resolved, origins, ""),
+      ...errors.length > 0 ? { diagnostics: toFindings(errors, document) } : {}
     };
+  };
+};
+export {
+  createLintResolver
 };

package/dist/lint/ruleset-loader.js

@@ -1,31 +1,33 @@
-import { existsSync } from 'node:fs';
-import { readFile } from 'node:fs/promises';
-import { dirname, isAbsolute, join, resolve } from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { parseWithPointers } from '@amritk/lint';
-const RULESET_FILENAMES = ['.lint.yaml', '.lint.yml', '.lint.json', '.lint.js', '.lint.mjs'];
-/** Loads a ruleset definition from a YAML, JSON, or JS/MJS file. */
-export const loadRuleset = async (path) => {
-    const absolute = isAbsolute(path) ? path : resolve(process.cwd(), path);
-    if (/\.(c|m)?js$/.test(absolute)) {
-        const module = await import(pathToFileURL(absolute).href);
-        return (module.default ?? module);
-    }
-    const content = await readFile(absolute, 'utf8');
-    return parseWithPointers(content).data;
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { parseWithPointers } from "@amritk/lint";
+const RULESET_FILENAMES = [".lint.yaml", ".lint.yml", ".lint.json", ".lint.js", ".lint.mjs"];
+const loadRuleset = async (path) => {
+  const absolute = isAbsolute(path) ? path : resolve(process.cwd(), path);
+  if (/\.(c|m)?js$/.test(absolute)) {
+    const module = await import(pathToFileURL(absolute).href);
+    return module.default ?? module;
+  }
+  const content = await readFile(absolute, "utf8");
+  return parseWithPointers(content).data;
 };
-/** Walks up from a directory looking for a `.lint.*` ruleset file. */
-export const discoverRuleset = (startDir) => {
-    let dir = resolve(startDir);
-    while (true) {
-        for (const name of RULESET_FILENAMES) {
-            const candidate = join(dir, name);
-            if (existsSync(candidate))
-                return candidate;
-        }
-        const parent = dirname(dir);
-        if (parent === dir)
-            return undefined;
-        dir = parent;
+const discoverRuleset = (startDir) => {
+  let dir = resolve(startDir);
+  while (true) {
+    for (const name of RULESET_FILENAMES) {
+      const candidate = join(dir, name);
+      if (existsSync(candidate))
+        return candidate;
     }
+    const parent = dirname(dir);
+    if (parent === dir)
+      return void 0;
+    dir = parent;
+  }
+};
+export {
+  discoverRuleset,
+  loadRuleset
 };