@amritk/generate-parsers 0.19.3 → 0.19.4

package/dist/generators/generate-validation-expression.js

@@ -10,6 +10,7 @@ import { generateDiscriminatedUnionValidation } from "./generate-discriminated-u
 import { generateEnumCaseInsensitiveCoercion, generateEnumCheck } from "./generate-enum-check.js";
 import { generateNonDiscriminatedUnionValidation } from "./generate-non-discriminated-union-validation.js";
 import { generateSchemaChecks } from "./generate-schema-checks.js";
+import { generateUniqueItemsCheck } from "./generate-unique-items-check.js";
 const getInstanceCoercion = (accessor, instanceOf, defaultValue) => {
   if (instanceOf === "Date")
     return `((_d) => Number.isNaN(_d.getTime()) ? ${defaultValue} : _d)(new Date(${accessor} as string | number | Date))`;
@@ -55,7 +56,7 @@ const prefixItemsCapsLength = (schema) => {
   if (!isSchemaObject(schema))
     return false;
   const s = schema;
-  return s["items"] === false || s["additionalItems"] === false;
+  return (Object.hasOwn(s, "items") ? s["items"] : void 0) === false || (Object.hasOwn(s, "additionalItems") ? s["additionalItems"] : void 0) === false;
 };
 const singleTypeCheck = (accessor, type) => {
   switch (type) {
@@ -259,7 +260,7 @@ const generateValidationExpression = (key, schema, defaultValue, isRequired, roo
           checks.push(`${accessor}.length <= ${schema.maxItems}`);
         }
         if (hasUniqueItems(schema) && schema.uniqueItems === true) {
-          checks.push(`new Set(${accessor}).size === ${accessor}.length`);
+          checks.push(generateUniqueItemsCheck(accessor, schema));
         }
         break;
       }

package/dist/helpers/collect-imports.js

@@ -7,17 +7,17 @@ const collectImports = (schema, options) => {
   const typesOnly = options?.typesOnly === true;
   const importExt = options?.importExt ?? "js";
   const importMap = /* @__PURE__ */ new Map();
-  for (const [filename, typeName] of collectImportTargets(schema, options)) {
+  for (const [filename, { typeName, typeOnly }] of collectImportTargets(schema, options)) {
     const importPath = getImportPathForFilename(filename, importExt);
-    const importStatement = typesOnly ? `import type { ${typeName} } from '${importPath}';` : `import { type ${typeName}, parse${typeName}, validate${typeName}Shape } from '${importPath}';`;
+    const importStatement = typesOnly || typeOnly ? `import type { ${typeName} } from '${importPath}';` : `import { type ${typeName}, parse${typeName}, validate${typeName}Shape } from '${importPath}';`;
     importMap.set(filename, importStatement);
   }
   return Array.from(importMap.values()).sort();
 };
 const collectImportTypeNames = (schema, options) => {
   const names = /* @__PURE__ */ new Set();
-  for (const [, typeName] of collectImportTargets(schema, options))
-    names.add(typeName);
+  for (const [, target] of collectImportTargets(schema, options))
+    names.add(target.typeName);
   return names;
 };
 const collectImportTargets = (schema, options) => {
@@ -25,6 +25,8 @@ const collectImportTargets = (schema, options) => {
   const rootSchema = options?.rootSchema;
   const typeSuffix = options?.typeSuffix;
   const refs = /* @__PURE__ */ new Set();
+  const valueRefs = /* @__PURE__ */ new Set();
+  let typeOnlyDepth = 0;
   const collectRefsFromValue = (value) => {
     if (typeof value !== "object" || value === null) {
       return;
@@ -43,21 +45,34 @@ const collectImportTargets = (schema, options) => {
       const isPropertyFragment = isUri && ref.includes("#/properties/");
       if (isInternal || isUri && !isPropertyFragment) {
         refs.add(ref);
+        if (typeOnlyDepth === 0)
+          valueRefs.add(ref);
       }
       return;
     }
+    for (const keyword of ["prefixItems", "items"]) {
+      const positions = Object.hasOwn(record, keyword) ? record[keyword] : void 0;
+      if (!Array.isArray(positions))
+        continue;
+      typeOnlyDepth++;
+      for (const item of positions) {
+        collectRefsFromValue(item);
+      }
+      if (Object.hasOwn(record, "additionalItems"))
+        collectRefsFromValue(record["additionalItems"]);
+      typeOnlyDepth--;
+    }
     if (hasAdditionalProperties(record) && hasRef(record.additionalProperties)) {
       collectRefsFromValue(record.additionalProperties);
       return;
     }
-    if (record.type === "array" && hasItems(record) && hasRef(record.items)) {
+    if (record.type === "array" && hasItems(record) && !Array.isArray(record.items) && hasRef(record.items)) {
       collectRefsFromValue(record.items);
       return;
     }
-    if ("properties" in record && typeof record.properties === "object" && record.properties !== null) {
-      const props = record.properties;
-      for (const key in props) {
-        collectRefsFromValue(props[key]);
+    if (Object.hasOwn(record, "properties") && typeof record.properties === "object" && record.properties !== null) {
+      for (const value2 of Object.values(record.properties)) {
+        collectRefsFromValue(value2);
       }
     }
     if (hasOneOf(record)) {
@@ -75,22 +90,24 @@ const collectImportTargets = (schema, options) => {
         collectRefsFromValue(item);
       }
     }
-    if (hasItems(record)) {
+    if (hasItems(record) && !Array.isArray(record.items)) {
       collectRefsFromValue(record.items);
     }
     if (hasAdditionalProperties(record)) {
       collectRefsFromValue(record.additionalProperties);
     }
-    if ("patternProperties" in record && typeof record.patternProperties === "object" && record.patternProperties !== null) {
-      const patternProps = record.patternProperties;
-      for (const key in patternProps) {
-        collectRefsFromValue(patternProps[key]);
+    if (Object.hasOwn(record, "patternProperties") && typeof record.patternProperties === "object" && record.patternProperties !== null) {
+      for (const value2 of Object.values(record.patternProperties)) {
+        collectRefsFromValue(value2);
       }
     }
-    if ("then" in record) {
+    if (Object.hasOwn(record, "if")) {
+      collectRefsFromValue(record.if);
+    }
+    if (Object.hasOwn(record, "then")) {
       collectRefsFromValue(record.then);
     }
-    if ("else" in record) {
+    if (Object.hasOwn(record, "else")) {
       collectRefsFromValue(record.else);
     }
   };
@@ -101,26 +118,39 @@ const collectImportTargets = (schema, options) => {
     const isPropertyFragment = isUri && ref.includes("#/properties/");
     if (isInternal || isUri && !isPropertyFragment) {
       refs.add(ref);
+      valueRefs.add(ref);
     }
   }
-  if (typeof schema === "object" && schema !== null && "properties" in schema) {
-    const properties = schema.properties;
-    for (const key in properties) {
-      collectRefsFromValue(properties[key]);
+  if (typeof schema === "object" && schema !== null && Object.hasOwn(schema, "properties") && typeof schema.properties === "object" && schema.properties !== null) {
+    for (const value of Object.values(schema.properties)) {
+      collectRefsFromValue(value);
     }
   }
-  if (typeof schema === "object" && schema !== null && "additionalProperties" in schema) {
+  if (typeof schema === "object" && schema !== null && Object.hasOwn(schema, "additionalProperties")) {
     collectRefsFromValue(schema.additionalProperties);
   }
-  if (typeof schema === "object" && schema !== null && "patternProperties" in schema) {
-    const patternProps = schema.patternProperties;
-    for (const key in patternProps) {
-      collectRefsFromValue(patternProps[key]);
+  if (typeof schema === "object" && schema !== null && Object.hasOwn(schema, "patternProperties") && typeof schema.patternProperties === "object" && schema.patternProperties !== null) {
+    for (const value of Object.values(schema.patternProperties)) {
+      collectRefsFromValue(value);
     }
   }
-  if (typeof schema === "object" && schema !== null && hasItems(schema)) {
+  if (typeof schema === "object" && schema !== null && hasItems(schema) && !Array.isArray(schema.items)) {
     collectRefsFromValue(schema.items);
   }
+  if (typeof schema === "object" && schema !== null) {
+    const record = schema;
+    for (const keyword of ["prefixItems", "items"]) {
+      const positions = Object.hasOwn(record, keyword) ? record[keyword] : void 0;
+      if (!Array.isArray(positions))
+        continue;
+      typeOnlyDepth++;
+      for (const item of positions)
+        collectRefsFromValue(item);
+      if (Object.hasOwn(record, "additionalItems"))
+        collectRefsFromValue(record["additionalItems"]);
+      typeOnlyDepth--;
+    }
+  }
   if (typeof schema === "object" && schema !== null && hasOneOf(schema)) {
     for (const item of schema.oneOf) {
       collectRefsFromValue(item);
@@ -136,13 +166,13 @@ const collectImportTargets = (schema, options) => {
       collectRefsFromValue(item);
     }
   }
-  if (typeof schema === "object" && schema !== null && "if" in schema) {
+  if (typeof schema === "object" && schema !== null && Object.hasOwn(schema, "if")) {
     collectRefsFromValue(schema.if);
   }
-  if (typeof schema === "object" && schema !== null && "then" in schema) {
+  if (typeof schema === "object" && schema !== null && Object.hasOwn(schema, "then")) {
     collectRefsFromValue(schema.then);
   }
-  if (typeof schema === "object" && schema !== null && "else" in schema) {
+  if (typeof schema === "object" && schema !== null && Object.hasOwn(schema, "else")) {
     collectRefsFromValue(schema.else);
   }
   const targets = /* @__PURE__ */ new Map();
@@ -156,7 +186,8 @@ const collectImportTargets = (schema, options) => {
     if (selfFilename !== void 0 && filename === selfFilename) {
       continue;
     }
-    targets.set(filename, typeName);
+    const typeOnly = !valueRefs.has(ref) && (targets.get(filename)?.typeOnly ?? true);
+    targets.set(filename, { typeName, typeOnly });
   }
   return targets;
 };

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

@@ -26,8 +26,8 @@ const defaultMatchesType = (value, schema) => {
 const MAX_FALLBACK_ITEMS = 32;
 const arrayFallback = (schema) => {
   const record = schema;
-  const positions = Array.isArray(record["prefixItems"]) ? record["prefixItems"] : Array.isArray(record["items"]) ? record["items"] : [];
-  const tail = Array.isArray(record["items"]) ? record["additionalItems"] : record["items"];
+  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)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/generate-parsers",
-  "version": "0.19.3",
+  "version": "0.19.4",
   "description": "Generate TypeScript parsers and type definitions from JSON Schemas.",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -56,10 +56,10 @@
   },
   "dependencies": {
     "json-schema-typed": "^8.0.1",
-    "@amritk/helpers": "^0.15.3"
+    "@amritk/helpers": "^0.15.4"
   },
   "devDependencies": {
-    "@amritk/generate-markdown": "^0.4.8",
+    "@amritk/generate-markdown": "^0.4.9",
     "@sinclair/typebox": "^0.34.49",
     "ajv": "^8.17.1",
     "zod": "^4.4.3"