fix: make properties of file type optional

.github/actions/node/action.yaml

@@ -3,29 +3,14 @@ description: "Node.js & pnpm setup"
 runs:
   using: "composite"
   steps:
-    - uses: actions/setup-node@v3
-      with:
-        node-version: "18.x"
-        registry-url: "https://registry.npmjs.org"
     - uses: pnpm/action-setup@v4
       name: Install pnpm
-      id: pnpm-install
-      with:
-        run_install: false
 
-    - name: Get pnpm store directory
-      id: pnpm-cache
-      shell: bash
-      run: |
-        echo "STORE_PATH=$(pnpm store path)" >> $GITHUB_OUTPUT
-
-    - uses: actions/cache@v3
-      name: Setup pnpm cache
+    - uses: actions/setup-node@v4
       with:
-        path: ${{ steps.pnpm-cache.outputs.STORE_PATH }}
-        key: ${{ runner.os }}-pnpm-store-${{ hashFiles('**/pnpm-lock.yaml') }}
-        restore-keys: |
-          ${{ runner.os }}-pnpm-store-
+        node-version: "22.x"
+        registry-url: "https://registry.npmjs.org"
+        cache: "pnpm"
 
     - name: Install dependencies
       shell: bash

.github/workflows/CI.yml

@@ -11,14 +11,14 @@ jobs:
   check-style:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: ./.github/actions/node
       - run: pnpm check-style
 
   lint:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: ./.github/actions/node
       - run: pnpm lint
 
@@ -28,7 +28,7 @@ jobs:
       run:
         working-directory: lib
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: ./.github/actions/node
       - run: pnpm test
 
@@ -38,7 +38,7 @@ jobs:
       run:
         working-directory: lib
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: ./.github/actions/node
       - run: pnpm build
 
@@ -50,10 +50,10 @@ jobs:
         working-directory: lib
     if: github.ref == 'refs/heads/main'
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: ./.github/actions/node
         with:
-          node-version: 18.x
+          node-version: 22.x
       - uses: go-semantic-release/action@v1
         id: semrel
         with:

.gitignore

@@ -3,3 +3,4 @@ dist/
 .eslintcache
 coverage
 .idea
+lib/README.md

README.md

@@ -139,3 +139,8 @@ or target the whole object or individual properties.
   `refine()`, `custom()` and `instanceof` methods (and they will be
   ignored), but these are really just implementations of `check()`
   which is supported
+
+## Other projects
+
+- [json-schema-to-zodex](https://github.com/brettz9/json-schema-to-zodex)
+- [zod-to-json-schema](https://github.com/StefanTerdell/zod-to-json-schema)

demo/package.json

@@ -10,16 +10,16 @@
     "preview": "vite preview"
   },
   "dependencies": {
-    "react": "^19.1.0",
-    "react-dom": "^19.1.0",
-    "zod": "^3.25.64",
+    "react": "^19.2.5",
+    "react-dom": "^19.2.5",
+    "zod": "^4.3.6",
     "zodex": "workspace:*"
   },
   "devDependencies": {
-    "@types/react": "^19.1.8",
-    "@types/react-dom": "^19.1.6",
-    "@vitejs/plugin-react": "^4.5.2",
-    "typescript": "^5.8.3",
-    "vite": "^6.3.5"
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "@vitejs/plugin-react": "^6.0.1",
+    "typescript": "^6.0.3",
+    "vite": "^8.0.10"
   }
 }

demo/tsconfig.app.tsbuildinfo

@@ -1 +1 @@
-{"root":["./src/app.tsx","./src/main.tsx","./src/vite-env.d.ts"],"version":"5.8.3"}
+{"root":["./src/app.tsx","./src/main.tsx","./src/vite-env.d.ts"],"version":"6.0.3"}

demo/tsconfig.node.tsbuildinfo

@@ -1 +1 @@
-{"root":["./vite.config.ts"],"version":"5.8.3"}
+{"root":["./vite.config.ts"],"version":"6.0.3"}

eslint.config.js

@@ -4,10 +4,17 @@ import reactHooks from "eslint-plugin-react-hooks";
 import reactRefresh from "eslint-plugin-react-refresh";
 import globals from "globals";
 import tseslint from "typescript-eslint";
+import { defineConfig } from "eslint/config";
 
-export default tseslint.config(
+export default defineConfig(
   {
-    ignores: ["lib/schema.zodex.json", "**/dist/", ".idea", "coverage"],
+    ignores: [
+      "lib/schema.zodex.json",
+      "**/dist/",
+      ".idea",
+      "coverage",
+      "**/*.cjs",
+    ],
   },
   eslint.configs.recommended,
   ...tseslint.configs.recommended,

lib/.ncurc.cjs

@@ -0,0 +1,14 @@
+"use strict";
+
+module.exports = {
+  reject: [
+    // Until package is ESM-only
+    "type-fest",
+
+    // Until typescript-eslint supports @7
+    "typescript",
+
+    // Preference to avoid updating?
+    "prettier",
+  ],
+};

lib/dezerialize.ts

@@ -10,8 +10,10 @@ import {
   SzUnion,
   SzDiscriminatedUnion,
   SzIntersection,
+  SzXor,
   SzTuple,
   SzRecord,
+  SzLooseRecord,
   SzMap,
   SzSet,
   SzEnum,
@@ -147,48 +149,56 @@ export type Dezerialize<T extends SzType | SzRef> = T extends SzRef
                                                         Dezerialize<Key>,
                                                         Dezerialize<Value>
                                                       >
-                                                    : T extends SzMap<
+                                                    : T extends SzLooseRecord<
                                                           infer Key,
                                                           infer Value
                                                         >
-                                                      ? z.ZodMap<
+                                                      ? z.ZodRecord<
                                                           Dezerialize<Key>,
                                                           Dezerialize<Value>
-                                                        > // Enum
-                                                      : T extends SzEnum<
-                                                            infer Values
+                                                        >
+                                                      : T extends SzMap<
+                                                            infer Key,
+                                                            infer Value
                                                           >
-                                                        ? z.ZodEnum<Values> // Union/Intersection
-                                                        : T extends SzUnion<
-                                                              infer _Options
+                                                        ? z.ZodMap<
+                                                            Dezerialize<Key>,
+                                                            Dezerialize<Value>
+                                                          > // Enum
+                                                        : T extends SzEnum<
+                                                              infer Values
                                                             >
-                                                          ? z.ZodUnion<any>
-                                                          : T extends SzDiscriminatedUnion<
-                                                                infer Discriminator,
+                                                          ? z.ZodEnum<Values> // Union/Intersection
+                                                          : T extends SzUnion<
                                                                 infer _Options
                                                               >
-                                                            ? z.ZodDiscriminatedUnion<any>
-                                                            : T extends SzIntersection<
-                                                                  infer L,
-                                                                  infer R
+                                                            ? z.ZodUnion<any>
+                                                            : T extends SzDiscriminatedUnion<
+                                                                  infer Discriminator,
+                                                                  infer _Options
                                                                 >
-                                                              ? z.ZodIntersection<
-                                                                  Dezerialize<L>,
-                                                                  Dezerialize<R>
-                                                                > // Specials
-                                                              : T extends SzPromise<
-                                                                    infer Value
-                                                                  >
-                                                                ? z.ZodPromise<
-                                                                    Dezerialize<Value>
+                                                              ? z.ZodDiscriminatedUnion<any>
+                                                              : T extends SzIntersection<
+                                                                    infer L,
+                                                                    infer R
                                                                   >
-                                                                : T extends SzCatch<
+                                                                ? z.ZodIntersection<
+                                                                    Dezerialize<L>,
+                                                                    Dezerialize<R>
+                                                                  > // Specials
+                                                                : T extends SzPromise<
                                                                       infer Value
                                                                     >
-                                                                  ? z.ZodCatch<
+                                                                  ? z.ZodPromise<
                                                                       Dezerialize<Value>
                                                                     >
-                                                                  : any; // unknown;
+                                                                  : T extends SzCatch<
+                                                                        infer Value
+                                                                      >
+                                                                    ? z.ZodCatch<
+                                                                        Dezerialize<Value>
+                                                                      >
+                                                                    : any; // unknown;
 
 type DezerializersMap = {
   [T in SzType["type"]]: (
@@ -230,6 +240,14 @@ const getError = (shape: SzType, opts: DezerializerOptions) => {
 const d = dezerializeRefs;
 
 const dezerializers = {
+  function: (shape, opts) => {
+    const i = z.function({
+      input: d(shape.input, opts) as any,
+      output: d(shape.output, opts),
+    });
+
+    return getCustomChecks(i, shape, opts);
+  },
   number: (shape, opts) => {
     const method =
       shape.format && NUMBER_FORMATS.has(shape.format)
@@ -527,8 +545,25 @@ const dezerializers = {
     opts.pathToSchema.set(opts.path, i);
     return getCustomChecks(i, shape, opts);
   }) as any,
+  looseRecord: ((shape: SzLooseRecord, opts: DezerializerOptions) => {
+    const i = z.looseRecord(
+      checkRef(shape.key, opts) ||
+        (d(shape.key, {
+          ...opts,
+          path: opts.path + "/key",
+        }) as z.ZodString | z.ZodNumber | z.ZodSymbol),
+      checkRef(shape.value, opts) ||
+        d(shape.value, {
+          ...opts,
+          path: opts.path + "/value",
+        }),
+      getError(shape, opts),
+    );
+    opts.pathToSchema.set(opts.path, i);
+    return getCustomChecks(i, shape, opts);
+  }) as any,
   map: ((shape: SzMap<any, any>, opts: DezerializerOptions) => {
-    const i = z.map(
+    let i = z.map(
       checkRef(shape.key, opts) ||
         d(shape.key, {
           ...opts,
@@ -542,6 +577,14 @@ const dezerializers = {
       getError(shape, opts),
     );
 
+    if ("min" in shape && shape.min !== undefined) {
+      i = i.min(shape.min);
+    }
+
+    if ("max" in shape && shape.max !== undefined) {
+      i = i.max(shape.max);
+    }
+
     opts.pathToSchema.set(opts.path, i);
     return getCustomChecks(i, shape, opts);
   }) as any,
@@ -583,6 +626,21 @@ const dezerializers = {
     opts.pathToSchema.set(opts.path, i);
     return getCustomChecks(i, shape, opts);
   }) as any,
+  xor: ((shape: SzXor, opts: DezerializerOptions) => {
+    const i = z.xor(
+      shape.options.map(
+        (opt, idx) =>
+          checkRef(opt, opts) ||
+          d(opt, {
+            ...opts,
+            path: opts.path + "/options/" + idx,
+          }),
+      ) as any,
+      getError(shape, opts),
+    );
+    opts.pathToSchema.set(opts.path, i);
+    return getCustomChecks(i, shape, opts);
+  }) as any,
   intersection: ((shape: SzIntersection, opts: DezerializerOptions) => {
     const i = z.intersection(
       checkRef(shape.left, opts) ||
@@ -699,7 +757,15 @@ export function dezerializeRefs(
   if ("description" in shape && typeof shape.description === "string") {
     const { description, ...rest } = shape;
     const inner = d(rest, opts);
-    const result = inner.describe(description);
+    const result = inner.meta({ description });
+    opts.pathToSchema.set(opts.path, result);
+    return result;
+  }
+
+  if ("meta" in shape) {
+    const { meta, ...rest } = shape;
+    const inner = d(rest, opts);
+    const result = meta ? inner.meta(meta) : inner;
     opts.pathToSchema.set(opts.path, result);
     return result;
   }