@amritk/generate-parsers 0.16.3 → 0.17.0

package/dist/helpers/get-default-value.js

@@ -1,104 +1,84 @@
-import { getMjstPrimitive } from '@amritk/helpers/mjst-extension';
-import { hasAllOf, hasAnyOf, hasConst, hasDefault, hasEnum, hasExamples, hasOneOf, hasPattern, hasProperties, hasRequired, hasType, isSchemaObject, } from '@amritk/helpers/schema-guards';
-import { generateDefaultFromPattern } from '../generators/generate-default-from-pattern.js';
-/**
- * Returns the default value for a JSON Schema property.
- * Priority order: explicit default > first enum value > first example > union first schema > pattern-based > type-based.
- * These defaults ensure that parsing never fails, even with missing data.
- */
-export const getDefaultValue = (schema) => {
-    if (!isSchemaObject(schema)) {
-        return 'undefined';
+import { getMjstPrimitive } from "@amritk/helpers/mjst-extension";
+import { hasAllOf, hasAnyOf, hasConst, hasDefault, hasEnum, hasExamples, hasOneOf, hasPattern, hasProperties, hasRequired, hasType, isSchemaObject } from "@amritk/helpers/schema-guards";
+import { generateDefaultFromPattern } from "../generators/generate-default-from-pattern.js";
+const getDefaultValue = (schema) => {
+  if (!isSchemaObject(schema)) {
+    return "undefined";
+  }
+  if (hasDefault(schema)) {
+    return JSON.stringify(schema.default);
+  }
+  if (hasConst(schema)) {
+    return JSON.stringify(schema.const);
+  }
+  if (hasEnum(schema) && schema.enum.length > 0) {
+    return JSON.stringify(schema.enum[0]);
+  }
+  if (hasExamples(schema) && schema.examples.length > 0) {
+    return JSON.stringify(schema.examples[0]);
+  }
+  if (hasOneOf(schema) && schema.oneOf.length > 0) {
+    const firstSchema = schema.oneOf[0];
+    if (firstSchema !== void 0) {
+      return getDefaultValue(firstSchema);
     }
-    // Explicit default takes highest priority
-    if (hasDefault(schema)) {
-        return JSON.stringify(schema.default);
+  }
+  if (hasAnyOf(schema) && schema.anyOf.length > 0) {
+    const firstSchema = schema.anyOf[0];
+    if (firstSchema !== void 0) {
+      return getDefaultValue(firstSchema);
     }
-    // A `const` value is the only valid value, so it is also the default.
-    if (hasConst(schema)) {
-        return JSON.stringify(schema.const);
+  }
+  if (hasAllOf(schema) && schema.allOf.length > 0) {
+    const firstSchema = schema.allOf[0];
+    if (firstSchema !== void 0) {
+      return getDefaultValue(firstSchema);
     }
-    // Use first enum value if available
-    if (hasEnum(schema) && schema.enum.length > 0) {
-        return JSON.stringify(schema.enum[0]);
-    }
-    // Use first example if available
-    if (hasExamples(schema) && schema.examples.length > 0) {
-        return JSON.stringify(schema.examples[0]);
-    }
-    // Handle union types - use first schema's default
-    if (hasOneOf(schema) && schema.oneOf.length > 0) {
-        const firstSchema = schema.oneOf[0];
-        if (firstSchema !== undefined) {
-            return getDefaultValue(firstSchema);
-        }
-    }
-    if (hasAnyOf(schema) && schema.anyOf.length > 0) {
-        const firstSchema = schema.anyOf[0];
-        if (firstSchema !== undefined) {
-            return getDefaultValue(firstSchema);
+  }
+  if (getMjstPrimitive(schema) === "bigint") {
+    return "0n";
+  }
+  const rawType = schema["type"];
+  if (Array.isArray(rawType) && rawType.length > 0 && typeof rawType[0] === "string") {
+    return getDefaultValue({ ...schema, type: rawType[0] });
+  }
+  if (!hasType(schema)) {
+    return "undefined";
+  }
+  switch (schema.type) {
+    case "string": {
+      if (hasPattern(schema)) {
+        const patternDefault = generateDefaultFromPattern(schema.pattern);
+        if (patternDefault) {
+          return patternDefault;
         }
+      }
+      return '""';
     }
-    // Handle allOf - use first schema's default
-    if (hasAllOf(schema) && schema.allOf.length > 0) {
-        const firstSchema = schema.allOf[0];
-        if (firstSchema !== undefined) {
-            return getDefaultValue(firstSchema);
+    case "number":
+    case "integer":
+      return "0";
+    case "boolean":
+      return "false";
+    case "null":
+      return "null";
+    case "array":
+      return "[]";
+    case "object": {
+      if (hasProperties(schema) && hasRequired(schema)) {
+        const props = schema.properties;
+        const required = schema.required.filter((key) => Object.hasOwn(props, key));
+        const defaults = required.map((key) => getDefaultValue(props[key]));
+        if (defaults.length > 0 && !defaults.includes("undefined")) {
+          return `{ ${required.map((key, i) => `${JSON.stringify(key)}: ${defaults[i]}`).join(", ")} }`;
         }
+      }
+      return "{}";
     }
-    // x-mjst bigint has no native JSON type but a sensible zero default.
-    if (getMjstPrimitive(schema) === 'bigint') {
-        return '0n';
-    }
-    // Array-form `type` (e.g. `["string","null"]`): `hasType` is false for it, so
-    // without this a required-but-missing value would default to `undefined` —
-    // violating both `required` and the declared type. Derive the default from the
-    // first listed type so the fallback is a valid member.
-    const rawType = schema['type'];
-    if (Array.isArray(rawType) && rawType.length > 0 && typeof rawType[0] === 'string') {
-        return getDefaultValue({ ...schema, type: rawType[0] });
-    }
-    if (!hasType(schema)) {
-        return 'undefined';
-    }
-    switch (schema.type) {
-        case 'string': {
-            if (hasPattern(schema)) {
-                const patternDefault = generateDefaultFromPattern(schema.pattern);
-                if (patternDefault) {
-                    return patternDefault;
-                }
-            }
-            return '""';
-        }
-        case 'number':
-        case 'integer':
-            return '0';
-        case 'boolean':
-            return 'false';
-        case 'null':
-            return 'null';
-        case 'array':
-            return '[]';
-        case 'object': {
-            // A bare `{}` omits required properties, leaving the default invalid against
-            // its own type. Populate each required property with its own default so the
-            // fallback object is itself a valid instance.
-            if (hasProperties(schema) && hasRequired(schema)) {
-                const props = schema.properties;
-                const required = schema.required.filter((key) => Object.hasOwn(props, key));
-                const defaults = required.map((key) => getDefaultValue(props[key]));
-                // A required property whose schema has no concrete default (a `$ref` we
-                // can't resolve here, or a type-less schema) would otherwise emit
-                // `"key": undefined` — i.e. a *missing* required key. Don't build a
-                // partial object with holes; fall back to a bare `{}` for the whole node.
-                if (defaults.length > 0 && !defaults.includes('undefined')) {
-                    return `{ ${required.map((key, i) => `${JSON.stringify(key)}: ${defaults[i]}`).join(', ')} }`;
-                }
-            }
-            return '{}';
-        }
-        default:
-            return 'undefined';
-    }
+    default:
+      return "undefined";
+  }
+};
+export {
+  getDefaultValue
 };

package/dist/helpers/get-discriminator-value.js

@@ -1,19 +1,18 @@
-import { hasConst, hasEnum, hasProperties, isObjectSchema, isSchemaObject } from '@amritk/helpers/schema-guards';
-/**
- * Gets the discriminator value for a specific schema.
- * Returns the const value or single enum value if available.
- */
-export const getDiscriminatorValue = (schema, discriminatorKey) => {
-    if (isObjectSchema(schema) && hasProperties(schema)) {
-        const propSchema = schema.properties[discriminatorKey];
-        if (propSchema && isSchemaObject(propSchema)) {
-            if (hasConst(propSchema)) {
-                return propSchema.const;
-            }
-            if (hasEnum(propSchema) && propSchema.enum.length === 1) {
-                return propSchema.enum[0];
-            }
-        }
+import { hasConst, hasEnum, hasProperties, isObjectSchema, isSchemaObject } from "@amritk/helpers/schema-guards";
+const getDiscriminatorValue = (schema, discriminatorKey) => {
+  if (isObjectSchema(schema) && hasProperties(schema)) {
+    const propSchema = schema.properties[discriminatorKey];
+    if (propSchema && isSchemaObject(propSchema)) {
+      if (hasConst(propSchema)) {
+        return propSchema.const;
+      }
+      if (hasEnum(propSchema) && propSchema.enum.length === 1) {
+        return propSchema.enum[0];
+      }
     }
-    return null;
+  }
+  return null;
+};
+export {
+  getDiscriminatorValue
 };

package/dist/index.js

@@ -1 +1,4 @@
-export { buildSchema } from './generators/build-schema.js';
+import { buildSchema } from "./generators/build-schema.js";
+export {
+  buildSchema
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/generate-parsers",
-  "version": "0.16.3",
+  "version": "0.17.0",
   "description": "Generate TypeScript parsers and type definitions from JSON Schemas.",
   "module": "./dist/index.js",
   "type": "module",
@@ -29,7 +29,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-parsers",
     "generate-readme": "bun run ./scripts/generate-readme.ts",
@@ -48,8 +48,8 @@
   },
   "dependencies": {
     "json-schema-typed": "^8.0.1",
-    "@amritk/helpers": "0.13.2",
-    "@amritk/generate-markdown": "0.4.2"
+    "@amritk/helpers": "0.13.3",
+    "@amritk/generate-markdown": "0.4.3"
   },
   "devDependencies": {
     "@sinclair/typebox": "^0.34.49",