@amritk/generate-examples 0.5.1 → 0.5.3

package/dist/generators/generate-files.js

@@ -1,46 +1,29 @@
-import { generateTypeDefinition } from '@amritk/helpers/generate-type-definition';
-import { collectExampleImports } from './collect-example-imports.js';
-import { generateExampleConst } from './derive-example.js';
-import { generateArbitrary, VALIDATE_IMPORT_NAME, VALIDATE_IMPORT_STATEMENT } from './generate-arbitrary.js';
-/**
- * Generates a complete TypeScript example file from a JSON Schema.
- *
- * The file contains:
- * - An import of `fast-check` and imports for any `$ref` types and arbitraries
- * - The exported TypeScript type definition
- * - An exported `fast-check` arbitrary (`FooArbitrary`)
- * - An exported concrete example value (`fooExample`)
- *
- * @example
- * ```typescript
- * const schema = { type: 'object', properties: { title: { type: 'string' } }, required: ['title'] }
- * generateExampleFile(schema, 'Info')
- * // import * as fc from 'fast-check'
- * // export type Info = { title: string }
- * // export const InfoArbitrary: fc.Arbitrary<Info> = fc.record({ "title": fc.string() })
- * // export const infoExample: Info = { "title": "string" }
- * ```
- */
-export const generateExampleFile = (schema, typeName, options) => {
-    const typeSuffix = options?.typeSuffix ?? '';
-    const refImports = collectExampleImports(schema, {
-        selfRef: options?.selfRef,
-        rootSchema: options?.rootSchema,
-        typeSuffix,
-    });
-    const typeDefinition = generateTypeDefinition(schema, typeName, { typeSuffix });
-    const arbitrary = generateArbitrary(schema, typeName, typeSuffix, options?.lazyRefFilenames, options?.rootSchema);
-    const example = generateExampleConst(schema, typeName, options?.rootSchema);
-    let result = `import * as fc from 'fast-check'\n`;
-    // The arbitrary embeds a runtime validator only for schemas whose keywords no
-    // `fc.*` combinator captures; import it just for those files.
-    if (arbitrary.includes(`${VALIDATE_IMPORT_NAME}(`)) {
-        result += VALIDATE_IMPORT_STATEMENT + '\n';
-    }
-    for (const imp of refImports) {
-        result += imp + '\n';
-    }
-    result += '\n';
-    result += typeDefinition + '\n\n' + arbitrary + '\n\n' + example + '\n';
-    return result;
+import { generateTypeDefinition } from "@amritk/helpers/generate-type-definition";
+import { collectExampleImports } from "./collect-example-imports.js";
+import { generateExampleConst } from "./derive-example.js";
+import { generateArbitrary, VALIDATE_IMPORT_NAME, VALIDATE_IMPORT_STATEMENT } from "./generate-arbitrary.js";
+const generateExampleFile = (schema, typeName, options) => {
+  const typeSuffix = options?.typeSuffix ?? "";
+  const refImports = collectExampleImports(schema, {
+    selfRef: options?.selfRef,
+    rootSchema: options?.rootSchema,
+    typeSuffix
+  });
+  const typeDefinition = generateTypeDefinition(schema, typeName, { typeSuffix });
+  const arbitrary = generateArbitrary(schema, typeName, typeSuffix, options?.lazyRefFilenames, options?.rootSchema);
+  const example = generateExampleConst(schema, typeName, options?.rootSchema);
+  let result = `import * as fc from 'fast-check'
+`;
+  if (arbitrary.includes(`${VALIDATE_IMPORT_NAME}(`)) {
+    result += VALIDATE_IMPORT_STATEMENT + "\n";
+  }
+  for (const imp of refImports) {
+    result += imp + "\n";
+  }
+  result += "\n";
+  result += typeDefinition + "\n\n" + arbitrary + "\n\n" + example + "\n";
+  return result;
+};
+export {
+  generateExampleFile
 };

package/dist/generators/schema-validation.js

@@ -1,83 +1,60 @@
-import { isSchemaObject } from '@amritk/helpers/schema-guards';
-import { validateGuard } from '@amritk/runtime-validators';
-/**
- * Keywords the direct generators can't fully honour on their own, so a value they
- * produce must be re-checked against a real validator. `oneOf` is included because
- * neither path enforces its *exactly-one* exclusivity; `anyOf`/`allOf` are not,
- * since a single satisfied branch (already how they are generated) is enough.
- */
-const FILTER_KEYWORDS = new Set([
-    'if',
-    'then',
-    'else',
-    'not',
-    'oneOf',
-    'patternProperties',
-    'propertyNames',
-    'dependentRequired',
-    'dependentSchemas',
-    'dependencies',
-    'minProperties',
-    'maxProperties',
-    'contains',
+import { isSchemaObject } from "@amritk/helpers/schema-guards";
+import { validateGuard } from "@amritk/runtime-validators";
+const FILTER_KEYWORDS = /* @__PURE__ */ new Set([
+  "if",
+  "then",
+  "else",
+  "not",
+  "oneOf",
+  "patternProperties",
+  "propertyNames",
+  "dependentRequired",
+  "dependentSchemas",
+  "dependencies",
+  "minProperties",
+  "maxProperties",
+  "contains"
 ]);
-/**
- * Keys whose values are *data* (or reference targets), not applied subschemas, so
- * a `not`/`if`/… appearing inside them must not be mistaken for an applicator.
- * `$defs`/`definitions` hold *unapplied* definitions — a hard keyword there only
- * matters once referenced, and each referenced def gets its own generated file.
- */
-const SKIP_RECURSE = new Set(['enum', 'const', 'examples', 'default', '$ref', 'required', '$defs', 'definitions']);
-/**
- * True when `schema` (anywhere in its applied subschema tree) uses a keyword the
- * direct generators can't guarantee, so the generated value must be run through a
- * validating filter. `$ref`s are not followed — a referenced definition is emitted
- * as its own self-validating file.
- */
-export const needsValidationFilter = (schema) => {
-    const walk = (node) => {
-        if (Array.isArray(node))
-            return node.some(walk);
-        if (node === null || typeof node !== 'object')
-            return false;
-        const obj = node;
-        for (const key of Object.keys(obj)) {
-            if (FILTER_KEYWORDS.has(key))
-                return true;
-        }
-        for (const [key, value] of Object.entries(obj)) {
-            if (SKIP_RECURSE.has(key))
-                continue;
-            if (walk(value))
-                return true;
-        }
-        return false;
-    };
-    return walk(schema);
-};
-/**
- * Returns `schema` augmented with the root document's `$defs`/`definitions` so its
- * local `$ref`s (`#/$defs/…`) resolve when it is validated in isolation. The
- * schema's own definitions win on collision.
- */
-export const withResolvableDefs = (schema, rootSchema) => {
-    const base = isSchemaObject(schema) ? { ...schema } : { const: schema };
-    if (!rootSchema)
-        return base;
-    for (const key of ['$defs', 'definitions']) {
-        const rootDefs = rootSchema[key];
-        if (rootDefs && typeof rootDefs === 'object') {
-            base[key] = { ...rootDefs, ...(base[key] ?? {}) };
-        }
+const SKIP_RECURSE = /* @__PURE__ */ new Set(["enum", "const", "examples", "default", "$ref", "required", "$defs", "definitions"]);
+const needsValidationFilter = (schema) => {
+  const walk = (node) => {
+    if (Array.isArray(node))
+      return node.some(walk);
+    if (node === null || typeof node !== "object")
+      return false;
+    const obj = node;
+    for (const key of Object.keys(obj)) {
+      if (FILTER_KEYWORDS.has(key))
+        return true;
+    }
+    for (const [key, value] of Object.entries(obj)) {
+      if (SKIP_RECURSE.has(key))
+        continue;
+      if (walk(value))
+        return true;
     }
+    return false;
+  };
+  return walk(schema);
+};
+const withResolvableDefs = (schema, rootSchema) => {
+  const base = isSchemaObject(schema) ? { ...schema } : { const: schema };
+  if (!rootSchema)
     return base;
+  for (const key of ["$defs", "definitions"]) {
+    const rootDefs = rootSchema[key];
+    if (rootDefs && typeof rootDefs === "object") {
+      base[key] = { ...rootDefs, ...base[key] ?? {} };
+    }
+  }
+  return base;
+};
+const makeInstanceCheck = (schema, rootSchema) => {
+  const guard = validateGuard(withResolvableDefs(schema, rootSchema));
+  return (value) => guard(value) === true;
 };
-/**
- * Compiles a boolean validator for `schema` (with the root document's definitions
- * spliced in so local `$ref`s resolve). Used at generation time to accept/reject
- * candidate example values for keywords the deriver can't satisfy structurally.
- */
-export const makeInstanceCheck = (schema, rootSchema) => {
-    const guard = validateGuard(withResolvableDefs(schema, rootSchema));
-    return (value) => guard(value) === true;
+export {
+  makeInstanceCheck,
+  needsValidationFilter,
+  withResolvableDefs
 };

package/dist/index.js

@@ -1,3 +1,10 @@
-export { buildExampleSchema } from './generators/build-schema.js';
-export { deriveExample, generateExampleConst, serializeValue } from './generators/derive-example.js';
-export { generateArbitrary } from './generators/generate-arbitrary.js';
+import { buildExampleSchema } from "./generators/build-schema.js";
+import { deriveExample, generateExampleConst, serializeValue } from "./generators/derive-example.js";
+import { generateArbitrary } from "./generators/generate-arbitrary.js";
+export {
+  buildExampleSchema,
+  deriveExample,
+  generateArbitrary,
+  generateExampleConst,
+  serializeValue
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/generate-examples",
-  "version": "0.5.1",
+  "version": "0.5.3",
   "description": "Generate fast-check arbitraries and example values from JSON Schemas.",
   "module": "./dist/index.js",
   "type": "module",
@@ -32,7 +32,7 @@
     "access": "public"
   },
   "scripts": {
-    "build": "tsgo -p tsconfig.build.json && tsc-alias -p tsconfig.build.json -f",
+    "build": "tsgo -p tsconfig.build.json && tsc-alias -p tsconfig.build.json -f && node ../../scripts/strip-comments.mjs",
     "types:check": "tsgo -p . --noEmit",
     "test": "NODE_ENV=production vitest run --root ../.. generate-examples"
   },
@@ -47,8 +47,8 @@
   },
   "dependencies": {
     "json-schema-typed": "^8.0.1",
-    "@amritk/helpers": "0.13.1",
-    "@amritk/runtime-validators": "0.7.1"
+    "@amritk/helpers": "0.13.3",
+    "@amritk/runtime-validators": "0.7.3"
   },
   "devDependencies": {
     "ajv": "^8.17.1"