@amritk/generate-parsers 0.23.0 → 0.25.0

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

@@ -1,155 +0,0 @@
-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 defaultMatchesType = (value, schema) => {
-  if (!hasType(schema))
-    return true;
-  switch (schema.type) {
-    case "string":
-      return typeof value === "string";
-    case "number":
-      return typeof value === "number";
-    case "integer":
-      return typeof value === "number" && Number.isInteger(value);
-    case "boolean":
-      return typeof value === "boolean";
-    case "null":
-      return value === null;
-    case "array":
-      return Array.isArray(value);
-    case "object":
-      return typeof value === "object" && value !== null && !Array.isArray(value);
-    default:
-      return true;
-  }
-};
-const MAX_FALLBACK_ITEMS = 32;
-const arrayFallback = (schema) => {
-  const record = schema;
-  const positions = Array.isArray(Object.hasOwn(record, "prefixItems") ? record["prefixItems"] : void 0) ? Object.hasOwn(record, "prefixItems") ? record["prefixItems"] : void 0 : Array.isArray(Object.hasOwn(record, "items") ? record["items"] : void 0) ? Object.hasOwn(record, "items") ? record["items"] : void 0 : [];
-  const tail = Array.isArray(Object.hasOwn(record, "items") ? record["items"] : void 0) ? Object.hasOwn(record, "additionalItems") ? record["additionalItems"] : void 0 : Object.hasOwn(record, "items") ? record["items"] : void 0;
-  const minItems = typeof record["minItems"] === "number" ? record["minItems"] : 0;
-  const wanted = minItems > MAX_FALLBACK_ITEMS ? Math.min(minItems, positions.length) : minItems;
-  if (wanted === 0)
-    return "[]";
-  const elements = [];
-  for (let i = 0; i < wanted; i++) {
-    const elementSchema = i < positions.length ? positions[i] : tail;
-    if (elementSchema === void 0 || typeof elementSchema === "boolean")
-      return "[]";
-    const element = getDefaultValue(elementSchema);
-    if (element === "undefined")
-      return "[]";
-    elements.push(element);
-  }
-  return `[${elements.join(", ")}]`;
-};
-const MAX_FALLBACK_LENGTH = 256;
-const stringFallback = (schema) => {
-  const bounds = schema;
-  if (hasPattern(schema)) {
-    const patternDefault = generateDefaultFromPattern(schema.pattern, typeof bounds["minLength"] === "number" ? bounds["minLength"] : void 0, typeof bounds["maxLength"] === "number" ? bounds["maxLength"] : void 0);
-    if (patternDefault)
-      return patternDefault;
-    return '""';
-  }
-  const minLength = schema["minLength"];
-  if (typeof minLength !== "number" || !(minLength > 0))
-    return '""';
-  return JSON.stringify("x".repeat(Math.min(minLength, MAX_FALLBACK_LENGTH)));
-};
-const finiteKeyword = (schema, keyword) => {
-  const value = schema[keyword];
-  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
-};
-const numberFallback = (schema, integer) => {
-  const minimum = finiteKeyword(schema, "minimum");
-  const maximum = finiteKeyword(schema, "maximum");
-  const exclusiveMinimum = finiteKeyword(schema, "exclusiveMinimum");
-  const exclusiveMaximum = finiteKeyword(schema, "exclusiveMaximum");
-  const multipleOf = finiteKeyword(schema, "multipleOf");
-  const low = Math.max(minimum ?? -Infinity, exclusiveMinimum !== void 0 ? exclusiveMinimum + 1 : -Infinity);
-  const high = Math.min(maximum ?? Infinity, exclusiveMaximum !== void 0 ? exclusiveMaximum - 1 : Infinity);
-  let candidate = Math.min(Math.max(0, low), high);
-  if (integer)
-    candidate = Math.ceil(candidate);
-  if (multipleOf !== void 0 && multipleOf > 0 && candidate !== 0) {
-    candidate = Math.ceil(candidate / multipleOf) * multipleOf;
-  }
-  const satisfies = Number.isFinite(candidate) && (minimum === void 0 || candidate >= minimum) && (maximum === void 0 || candidate <= maximum) && (exclusiveMinimum === void 0 || candidate > exclusiveMinimum) && (exclusiveMaximum === void 0 || candidate < exclusiveMaximum) && (!integer || Number.isInteger(candidate)) && (multipleOf === void 0 || multipleOf <= 0 || Number.isInteger(candidate / multipleOf));
-  return satisfies ? String(candidate) : "0";
-};
-const getDefaultValue = (schema) => {
-  if (!isSchemaObject(schema)) {
-    return "undefined";
-  }
-  if (hasDefault(schema) && defaultMatchesType(schema.default, 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);
-    }
-  }
-  if (hasAnyOf(schema) && schema.anyOf.length > 0) {
-    const firstSchema = schema.anyOf[0];
-    if (firstSchema !== void 0) {
-      return getDefaultValue(firstSchema);
-    }
-  }
-  if (hasAllOf(schema) && schema.allOf.length > 0) {
-    const firstSchema = schema.allOf[0];
-    if (firstSchema !== void 0) {
-      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":
-      return stringFallback(schema);
-    case "number":
-    case "integer":
-      return numberFallback(schema, schema.type === "integer");
-    case "boolean":
-      return "false";
-    case "null":
-      return "null";
-    case "array":
-      return arrayFallback(schema);
-    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 "{}";
-    }
-    default:
-      return "undefined";
-  }
-};
-export {
-  getDefaultValue
-};

package/dist/helpers/get-discriminator-value.d.ts

@@ -1,6 +0,0 @@
-import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
-/**
- * Gets the discriminator value for a specific schema.
- * Returns the const value or single enum value if available.
- */
-export declare const getDiscriminatorValue: (schema: JSONSchema, discriminatorKey: string) => unknown | null;

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

@@ -1,18 +0,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;
-};
-export {
-  getDiscriminatorValue
-};

package/dist/types/schema-extensions.d.ts

@@ -1,34 +0,0 @@
-import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
-/**
- * Defines custom extension properties that can be added to specific schema
- * definitions during the build process.
- *
- * The outer key is the definition name (matching the $defs key in the root
- * schema, e.g., "parameter", "operation"). The inner key is the extension
- * property name (e.g., "x-enabled", "x-internal"). The value is a JSON
- * Schema that validates the extension property and generates its TypeScript type.
- *
- * Extensions are merged into the schema properties before type and parser
- * generation, so each extension gets full type safety and runtime validation.
- *
- * @example
- * ```typescript
- * const extensions: SchemaExtensions = {
- *   parameter: {
- *     'x-enabled': { type: 'boolean' },
- *     'x-internal': { type: 'boolean', default: false },
- *   },
- *   operation: {
- *     'x-codegen': {
- *       type: 'object',
- *       properties: {
- *         methodName: { type: 'string' },
- *       },
- *     },
- *   },
- * }
- *
- * const files = buildSchema(schema, 'Document', markdownDocumentation, extensions)
- * ```
- */
-export type SchemaExtensions = Record<string, Record<string, JSONSchema>>;