@mxpicture/zod-meta 0.1.0

package/README.md

@@ -0,0 +1,38 @@
+# zod-meta-lib
+
+Example Node library using TypeScript and Zod. Produces:
+
+- CommonJS build at `dist/cjs`
+- ESM build at `dist/esm`
+- Type declarations at `dist/types`
+
+Usage (after npm publish or local link):
+
+ESM:
+
+```js
+import { validateUser } from "zod-meta-lib";
+```
+
+CommonJS:
+
+```js
+const { validateUser } = require("zod-meta-lib");
+```
+
+Build:
+
+```bash
+npm install
+npm run build
+```
+
+## Setup husky
+
+```bash
+npm install --save-dev @commitlint/config-conventional @commitlint/cli husky commitizen cz-conventional-changelog husky
+npx husky-init
+npm i
+npm run prepare
+npx husky add .husky/commit-msg 'npx --no -- commitlint --edit "$1"'
+```

package/dist/cjs/Meta.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Meta = void 0;
+const common_1 = require("./common");
+class Meta {
+    constructor(props) {
+        this.props = props;
+    }
+    items() {
+        return (0, common_1.metaItems)(this.props);
+    }
+}
+exports.Meta = Meta;

package/dist/cjs/common.js

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.metaItems = exports.castEnum = exports.castOptional = exports.castRecord = exports.castObject = exports.castArray = exports.castDate = exports.castInt = exports.castNumber = exports.castString = exports.castBool = void 0;
+const types_1 = require("./types");
+const castType = (type, prop) => (prop._zod.def.type === type ? prop : undefined);
+const castBool = (p) => castType(types_1.MetaType.boolean, p);
+exports.castBool = castBool;
+const castString = (p) => castType(types_1.MetaType.string, p);
+exports.castString = castString;
+const castNumber = (p) => castType(types_1.MetaType.number, p);
+exports.castNumber = castNumber;
+const castInt = (p) => castType(types_1.MetaType.int, p);
+exports.castInt = castInt;
+const castDate = (p) => castType(types_1.MetaType.date, p);
+exports.castDate = castDate;
+const castArray = (p) => castType(types_1.MetaType.array, p);
+exports.castArray = castArray;
+const castObject = (p) => castType(types_1.MetaType.object, p);
+exports.castObject = castObject;
+const castRecord = (p) => castType(types_1.MetaType.record, p);
+exports.castRecord = castRecord;
+const castOptional = (p) => castType(types_1.MetaInternalType.optional, p);
+exports.castOptional = castOptional;
+const castEnum = (p) => castType(types_1.MetaType.enum, p);
+exports.castEnum = castEnum;
+const metaFunctions = {
+    boolean: (name, _prop, optional) => {
+        const prop = (0, exports.castBool)(_prop);
+        if (!prop)
+            return;
+        const meta = prop.meta();
+        return {
+            boolean: {
+                name,
+                title: meta?.title,
+                description: meta?.description,
+                type: types_1.MetaType.boolean,
+                optional,
+            },
+        };
+    },
+    string: (name, _prop, optional) => {
+        const prop = (0, exports.castString)(_prop);
+        if (!prop)
+            return;
+        const meta = prop.meta();
+        const checks = metaChecks(prop._zod.def);
+        return {
+            string: {
+                name,
+                title: meta?.title,
+                description: meta?.description,
+                type: types_1.MetaType.string,
+                minLength: checks.min_length?.minimum,
+                maxLength: checks.max_length?.maximum,
+                exactLength: checks.length_equals?.length,
+                regex: checks.regex?.pattern?.toString() ??
+                    checks.string_format?.pattern?.toString(),
+                format: checks.regex?.format ?? checks.string_format?.format,
+                optional,
+            },
+        };
+    },
+    number: (name, _prop, optional) => {
+        const prop = (0, exports.castNumber)(_prop);
+        if (!prop)
+            return;
+        const meta = prop.meta();
+        const checks = metaChecks(prop._zod.def);
+        return {
+            number: {
+                name,
+                title: meta?.title,
+                description: meta?.description,
+                type: types_1.MetaType.number,
+                minValue: checks.greater_than?.value,
+                minInclusive: checks.greater_than?.inclusive,
+                maxValue: checks.less_than?.value,
+                maxInclusive: checks.less_than?.inclusive,
+                multipleOf: checks.multiple_of?.value,
+                format: checks.number_format?.format,
+                optional,
+            },
+        };
+    },
+    int: (name, _prop, optional) => {
+        const prop = (0, exports.castInt)(_prop);
+        if (!prop)
+            return;
+        const meta = prop.meta();
+        const checks = metaChecks(prop._zod.def);
+        return {
+            int: {
+                name,
+                title: meta?.title,
+                description: meta?.description,
+                type: types_1.MetaType.int,
+                minValue: checks.greater_than?.value,
+                minInclusive: checks.greater_than?.inclusive,
+                maxValue: checks.less_than?.value,
+                maxInclusive: checks.less_than?.inclusive,
+                multipleOf: checks.multiple_of?.value,
+                format: checks.number_format?.format,
+                optional,
+            },
+        };
+    },
+    date: (name, _prop, optional) => {
+        const prop = (0, exports.castDate)(_prop);
+        if (!prop)
+            return;
+        const meta = prop.meta();
+        return {
+            date: {
+                name,
+                title: meta?.title,
+                description: meta?.description,
+                type: types_1.MetaType.date,
+                optional,
+            },
+        };
+    },
+    array: (name, _prop, optional) => {
+        const prop = (0, exports.castArray)(_prop);
+        if (!prop)
+            return;
+        const meta = prop.meta();
+        const inner = prop.unwrap();
+        const checks = metaChecks(prop._zod.def);
+        return {
+            array: {
+                name,
+                title: meta?.title,
+                description: meta?.description,
+                type: types_1.MetaType.array,
+                item: metaItem(`${name}[]`, inner),
+                minLength: checks.min_length?.minimum,
+                maxLength: checks.max_length?.maximum,
+                exactLength: checks.length_equals?.length,
+                optional,
+            },
+        };
+    },
+    record: (name, _prop, optional) => {
+        const prop = (0, exports.castRecord)(_prop);
+        if (!prop)
+            return;
+        const meta = prop.meta();
+        return {
+            record: {
+                name,
+                title: meta?.title,
+                description: meta?.description,
+                type: types_1.MetaType.record,
+                keyType: metaItem("keyType", prop.def.keyType),
+                valueType: metaItem("valueType", prop.def.valueType),
+                optional,
+            },
+        };
+    },
+    object: (name, _prop, optional) => {
+        const prop = (0, exports.castObject)(_prop);
+        if (!prop)
+            return;
+        const meta = prop.meta();
+        return {
+            object: {
+                name,
+                title: meta?.title,
+                description: meta?.description,
+                type: types_1.MetaType.object,
+                properties: (0, exports.metaItems)(prop.def.shape),
+                optional,
+            },
+        };
+    },
+    enum: (name, _prop, optional) => {
+        const prop = (0, exports.castEnum)(_prop);
+        if (!prop)
+            return;
+        const meta = prop.meta();
+        const entries = Object.entries(prop.def.entries).map(([key, value]) => {
+            const titles = Array.isArray(meta?.enumEntryTitles)
+                ? meta.enumEntryTitles
+                : [];
+            return {
+                key,
+                value,
+                title: titles.find((t) => t.value === value)?.title,
+            };
+        });
+        return {
+            enum: {
+                name,
+                title: meta?.title,
+                description: meta?.description,
+                type: types_1.MetaType.enum,
+                entries,
+                optional,
+            },
+        };
+    },
+    optional: (name, _prop) => {
+        const prop = (0, exports.castOptional)(_prop);
+        if (!prop)
+            return;
+        const inner = prop.unwrap();
+        return metaItem(name, inner, true);
+    },
+};
+const metaCheck = (def) => {
+    const checks = {};
+    const found = types_1.MetaCheckTypeList.find((i) => i.value === def.check);
+    if (!found)
+        throw new Error(`Check type ${def.check} not supported`);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    checks[found.value] = def;
+    return checks;
+};
+const metaChecks = (type) => {
+    let results = {};
+    const checks = type.def?.checks ??
+        type.checks ??
+        [];
+    for (const check of checks)
+        results = { ...results, ...metaCheck(check._zod.def) };
+    return results;
+};
+const metaItem = (name, prop, optional) => {
+    for (const f of Object.values(metaFunctions)) {
+        const item = f(name, prop, optional);
+        if (item)
+            return item;
+    }
+    throw new Error(`Property ${name} (${prop._zod.def.type}) failed`);
+};
+const metaItems = (props) => {
+    const items = [];
+    for (const [name, prop] of Object.entries(props))
+        items.push(metaItem(name, prop));
+    return items;
+};
+exports.metaItems = metaItems;

package/dist/cjs/index.js

@@ -0,0 +1,42 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./lib"), exports);
+// A default export can help some consumers using require()
+const _all = __importStar(require("./lib"));
+exports.default = _all;

package/dist/cjs/lib.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Meta"), exports);
+__exportStar(require("./common"), exports);
+__exportStar(require("./types"), exports);

package/dist/cjs/package.js

@@ -0,0 +1,21 @@
+"use strict";
+// eslint-disable-next-line @typescript-eslint/triple-slash-reference
+/// <reference path="./types/zod.d.ts" />
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Re-export your public types/exports so this file becomes the root .d.ts for the package.
+// Adjust the relative path if your source layout differs.
+__exportStar(require("./lib"), exports);

package/dist/cjs/types.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetaCheckTypeList = exports.MetaCheckType = exports.MetaInternalType = exports.MetaTypeList = exports.MetaType = void 0;
+var MetaType;
+(function (MetaType) {
+    MetaType["string"] = "string";
+    MetaType["number"] = "number";
+    MetaType["int"] = "int";
+    MetaType["date"] = "date";
+    MetaType["boolean"] = "boolean";
+    MetaType["array"] = "array";
+    MetaType["record"] = "record";
+    MetaType["object"] = "object";
+    MetaType["enum"] = "enum";
+})(MetaType || (exports.MetaType = MetaType = {}));
+exports.MetaTypeList = Object.entries(MetaType).map(([key, value]) => ({
+    key,
+    value,
+}));
+var MetaInternalType;
+(function (MetaInternalType) {
+    MetaInternalType["optional"] = "optional";
+})(MetaInternalType || (exports.MetaInternalType = MetaInternalType = {}));
+var MetaCheckType;
+(function (MetaCheckType) {
+    MetaCheckType["less_than"] = "less_than";
+    MetaCheckType["greater_than"] = "greater_than";
+    MetaCheckType["multiple_of"] = "multiple_of";
+    MetaCheckType["number_format"] = "number_format";
+    MetaCheckType["bigint_format"] = "bigint_format";
+    MetaCheckType["min_size"] = "min_size";
+    MetaCheckType["max_size"] = "max_size";
+    MetaCheckType["size_equals"] = "size_equals";
+    MetaCheckType["min_length"] = "min_length";
+    MetaCheckType["max_length"] = "max_length";
+    MetaCheckType["length_equals"] = "length_equals";
+    MetaCheckType["string_format"] = "string_format";
+    MetaCheckType["regex"] = "regex";
+})(MetaCheckType || (exports.MetaCheckType = MetaCheckType = {}));
+exports.MetaCheckTypeList = Object.entries(MetaCheckType).map(([key, value]) => ({
+    key,
+    value,
+}));

package/dist/esm/Meta.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Meta = void 0;
+const common_1 = require("./common");
+class Meta {
+    constructor(props) {
+        this.props = props;
+    }
+    items() {
+        return (0, common_1.metaItems)(this.props);
+    }
+}
+exports.Meta = Meta;

package/dist/esm/common.js

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.metaItems = exports.castEnum = exports.castOptional = exports.castRecord = exports.castObject = exports.castArray = exports.castDate = exports.castInt = exports.castNumber = exports.castString = exports.castBool = void 0;
+const types_1 = require("./types");
+const castType = (type, prop) => (prop._zod.def.type === type ? prop : undefined);
+const castBool = (p) => castType(types_1.MetaType.boolean, p);
+exports.castBool = castBool;
+const castString = (p) => castType(types_1.MetaType.string, p);
+exports.castString = castString;
+const castNumber = (p) => castType(types_1.MetaType.number, p);
+exports.castNumber = castNumber;
+const castInt = (p) => castType(types_1.MetaType.int, p);
+exports.castInt = castInt;
+const castDate = (p) => castType(types_1.MetaType.date, p);
+exports.castDate = castDate;
+const castArray = (p) => castType(types_1.MetaType.array, p);
+exports.castArray = castArray;
+const castObject = (p) => castType(types_1.MetaType.object, p);
+exports.castObject = castObject;
+const castRecord = (p) => castType(types_1.MetaType.record, p);
+exports.castRecord = castRecord;
+const castOptional = (p) => castType(types_1.MetaInternalType.optional, p);
+exports.castOptional = castOptional;
+const castEnum = (p) => castType(types_1.MetaType.enum, p);
+exports.castEnum = castEnum;
+const metaFunctions = {
+    boolean: (name, _prop, optional) => {
+        const prop = (0, exports.castBool)(_prop);
+        if (!prop)
+            return;
+        const meta = prop.meta();
+        return {
+            boolean: {
+                name,
+                title: meta?.title,
+                description: meta?.description,
+                type: types_1.MetaType.boolean,
+                optional,
+            },
+        };
+    },
+    string: (name, _prop, optional) => {
+        const prop = (0, exports.castString)(_prop);
+        if (!prop)
+            return;
+        const meta = prop.meta();
+        const checks = metaChecks(prop._zod.def);
+        return {
+            string: {
+                name,
+                title: meta?.title,
+                description: meta?.description,
+                type: types_1.MetaType.string,
+                minLength: checks.min_length?.minimum,
+                maxLength: checks.max_length?.maximum,
+                exactLength: checks.length_equals?.length,
+                regex: checks.regex?.pattern?.toString() ??
+                    checks.string_format?.pattern?.toString(),
+                format: checks.regex?.format ?? checks.string_format?.format,
+                optional,
+            },
+        };
+    },
+    number: (name, _prop, optional) => {
+        const prop = (0, exports.castNumber)(_prop);
+        if (!prop)
+            return;
+        const meta = prop.meta();
+        const checks = metaChecks(prop._zod.def);
+        return {
+            number: {
+                name,
+                title: meta?.title,
+                description: meta?.description,
+                type: types_1.MetaType.number,
+                minValue: checks.greater_than?.value,
+                minInclusive: checks.greater_than?.inclusive,
+                maxValue: checks.less_than?.value,
+                maxInclusive: checks.less_than?.inclusive,
+                multipleOf: checks.multiple_of?.value,
+                format: checks.number_format?.format,
+                optional,
+            },
+        };
+    },
+    int: (name, _prop, optional) => {
+        const prop = (0, exports.castInt)(_prop);
+        if (!prop)
+            return;
+        const meta = prop.meta();
+        const checks = metaChecks(prop._zod.def);
+        return {
+            int: {
+                name,
+                title: meta?.title,
+                description: meta?.description,
+                type: types_1.MetaType.int,
+                minValue: checks.greater_than?.value,
+                minInclusive: checks.greater_than?.inclusive,
+                maxValue: checks.less_than?.value,
+                maxInclusive: checks.less_than?.inclusive,
+                multipleOf: checks.multiple_of?.value,
+                format: checks.number_format?.format,
+                optional,
+            },
+        };
+    },
+    date: (name, _prop, optional) => {
+        const prop = (0, exports.castDate)(_prop);
+        if (!prop)
+            return;
+        const meta = prop.meta();
+        return {
+            date: {
+                name,
+                title: meta?.title,
+                description: meta?.description,
+                type: types_1.MetaType.date,
+                optional,
+            },
+        };
+    },
+    array: (name, _prop, optional) => {
+        const prop = (0, exports.castArray)(_prop);
+        if (!prop)
+            return;
+        const meta = prop.meta();
+        const inner = prop.unwrap();
+        const checks = metaChecks(prop._zod.def);
+        return {
+            array: {
+                name,
+                title: meta?.title,
+                description: meta?.description,
+                type: types_1.MetaType.array,
+                item: metaItem(`${name}[]`, inner),
+                minLength: checks.min_length?.minimum,
+                maxLength: checks.max_length?.maximum,
+                exactLength: checks.length_equals?.length,
+                optional,
+            },
+        };
+    },
+    record: (name, _prop, optional) => {
+        const prop = (0, exports.castRecord)(_prop);
+        if (!prop)
+            return;
+        const meta = prop.meta();
+        return {
+            record: {
+                name,
+                title: meta?.title,
+                description: meta?.description,
+                type: types_1.MetaType.record,
+                keyType: metaItem("keyType", prop.def.keyType),
+                valueType: metaItem("valueType", prop.def.valueType),
+                optional,
+            },
+        };
+    },
+    object: (name, _prop, optional) => {
+        const prop = (0, exports.castObject)(_prop);
+        if (!prop)
+            return;
+        const meta = prop.meta();
+        return {
+            object: {
+                name,
+                title: meta?.title,
+                description: meta?.description,
+                type: types_1.MetaType.object,
+                properties: (0, exports.metaItems)(prop.def.shape),
+                optional,
+            },
+        };
+    },
+    enum: (name, _prop, optional) => {
+        const prop = (0, exports.castEnum)(_prop);
+        if (!prop)
+            return;
+        const meta = prop.meta();
+        const entries = Object.entries(prop.def.entries).map(([key, value]) => {
+            const titles = Array.isArray(meta?.enumEntryTitles)
+                ? meta.enumEntryTitles
+                : [];
+            return {
+                key,
+                value,
+                title: titles.find((t) => t.value === value)?.title,
+            };
+        });
+        return {
+            enum: {
+                name,
+                title: meta?.title,
+                description: meta?.description,
+                type: types_1.MetaType.enum,
+                entries,
+                optional,
+            },
+        };
+    },
+    optional: (name, _prop) => {
+        const prop = (0, exports.castOptional)(_prop);
+        if (!prop)
+            return;
+        const inner = prop.unwrap();
+        return metaItem(name, inner, true);
+    },
+};
+const metaCheck = (def) => {
+    const checks = {};
+    const found = types_1.MetaCheckTypeList.find((i) => i.value === def.check);
+    if (!found)
+        throw new Error(`Check type ${def.check} not supported`);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    checks[found.value] = def;
+    return checks;
+};
+const metaChecks = (type) => {
+    let results = {};
+    const checks = type.def?.checks ??
+        type.checks ??
+        [];
+    for (const check of checks)
+        results = { ...results, ...metaCheck(check._zod.def) };
+    return results;
+};
+const metaItem = (name, prop, optional) => {
+    for (const f of Object.values(metaFunctions)) {
+        const item = f(name, prop, optional);
+        if (item)
+            return item;
+    }
+    throw new Error(`Property ${name} (${prop._zod.def.type}) failed`);
+};
+const metaItems = (props) => {
+    const items = [];
+    for (const [name, prop] of Object.entries(props))
+        items.push(metaItem(name, prop));
+    return items;
+};
+exports.metaItems = metaItems;

package/dist/esm/index.js

@@ -0,0 +1,42 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./lib"), exports);
+// A default export can help some consumers using require()
+const _all = __importStar(require("./lib"));
+exports.default = _all;

package/dist/esm/lib.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Meta"), exports);
+__exportStar(require("./common"), exports);
+__exportStar(require("./types"), exports);

package/dist/esm/package.js

@@ -0,0 +1,21 @@
+"use strict";
+// eslint-disable-next-line @typescript-eslint/triple-slash-reference
+/// <reference path="./types/zod.d.ts" />
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Re-export your public types/exports so this file becomes the root .d.ts for the package.
+// Adjust the relative path if your source layout differs.
+__exportStar(require("./lib"), exports);

package/dist/esm/types.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetaCheckTypeList = exports.MetaCheckType = exports.MetaInternalType = exports.MetaTypeList = exports.MetaType = void 0;
+var MetaType;
+(function (MetaType) {
+    MetaType["string"] = "string";
+    MetaType["number"] = "number";
+    MetaType["int"] = "int";
+    MetaType["date"] = "date";
+    MetaType["boolean"] = "boolean";
+    MetaType["array"] = "array";
+    MetaType["record"] = "record";
+    MetaType["object"] = "object";
+    MetaType["enum"] = "enum";
+})(MetaType || (exports.MetaType = MetaType = {}));
+exports.MetaTypeList = Object.entries(MetaType).map(([key, value]) => ({
+    key,
+    value,
+}));
+var MetaInternalType;
+(function (MetaInternalType) {
+    MetaInternalType["optional"] = "optional";
+})(MetaInternalType || (exports.MetaInternalType = MetaInternalType = {}));
+var MetaCheckType;
+(function (MetaCheckType) {
+    MetaCheckType["less_than"] = "less_than";
+    MetaCheckType["greater_than"] = "greater_than";
+    MetaCheckType["multiple_of"] = "multiple_of";
+    MetaCheckType["number_format"] = "number_format";
+    MetaCheckType["bigint_format"] = "bigint_format";
+    MetaCheckType["min_size"] = "min_size";
+    MetaCheckType["max_size"] = "max_size";
+    MetaCheckType["size_equals"] = "size_equals";
+    MetaCheckType["min_length"] = "min_length";
+    MetaCheckType["max_length"] = "max_length";
+    MetaCheckType["length_equals"] = "length_equals";
+    MetaCheckType["string_format"] = "string_format";
+    MetaCheckType["regex"] = "regex";
+})(MetaCheckType || (exports.MetaCheckType = MetaCheckType = {}));
+exports.MetaCheckTypeList = Object.entries(MetaCheckType).map(([key, value]) => ({
+    key,
+    value,
+}));

package/dist/types/Meta.d.ts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+import { MetaItem } from "./types";
+export declare class Meta {
+    protected readonly props: z.ZodRawShape;
+    constructor(props: z.ZodRawShape);
+    items(): MetaItem[];
+}

package/dist/types/common.d.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+import { $ZodType } from "zod/v4/core";
+import { MetaItem } from "./types";
+export declare const castBool: (p: $ZodType) => z.ZodBoolean | undefined;
+export declare const castString: (p: $ZodType) => z.ZodString | undefined;
+export declare const castNumber: (p: $ZodType) => z.ZodNumber | undefined;
+export declare const castInt: (p: $ZodType) => z.ZodInt | undefined;
+export declare const castDate: (p: $ZodType) => z.ZodDate | undefined;
+export declare const castArray: (p: $ZodType) => z.ZodArray<z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>> | undefined;
+export declare const castObject: (p: $ZodType) => z.ZodObject<z.core.$ZodLooseShape, z.core.$strip> | undefined;
+export declare const castRecord: (p: $ZodType) => z.ZodRecord<z.core.$ZodRecordKey, z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>> | undefined;
+export declare const castOptional: (p: $ZodType) => z.ZodOptional<z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>> | undefined;
+export declare const castEnum: (p: $ZodType) => z.ZodEnum<Readonly<Record<string, z.core.util.EnumValue>>> | undefined;
+export declare const metaItems: (props: z.ZodRawShape) => MetaItem[];

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./lib";
+import * as _all from "./lib";
+export default _all;

package/dist/types/lib.d.ts

@@ -0,0 +1,3 @@
+export * from "./Meta";
+export * from "./common";
+export * from "./types";

package/dist/types/package.d.ts

@@ -0,0 +1 @@
+export * from "./lib";

package/dist/types/types.d.ts

@@ -0,0 +1,140 @@
+import { $ZodCheckBigIntFormatDef, $ZodCheckGreaterThanDef, $ZodCheckLengthEqualsDef, $ZodCheckLessThanDef, $ZodCheckMaxLengthDef, $ZodCheckMaxSizeDef, $ZodCheckMinLengthDef, $ZodCheckMinSizeDef, $ZodCheckMultipleOfDef, $ZodCheckNumberFormatDef, $ZodCheckRegexDef, $ZodCheckSizeEqualsDef, $ZodCheckStringFormatDef, $ZodNumberFormats, $ZodStringFormats, $ZodType } from "zod/v4/core";
+export declare enum MetaType {
+    string = "string",
+    number = "number",
+    int = "int",
+    date = "date",
+    boolean = "boolean",
+    array = "array",
+    record = "record",
+    object = "object",
+    enum = "enum"
+}
+export declare const MetaTypeList: {
+    key: string;
+    value: MetaType;
+}[];
+export declare enum MetaInternalType {
+    optional = "optional"
+}
+export declare enum MetaCheckType {
+    less_than = "less_than",
+    greater_than = "greater_than",
+    multiple_of = "multiple_of",
+    number_format = "number_format",
+    bigint_format = "bigint_format",
+    min_size = "min_size",
+    max_size = "max_size",
+    size_equals = "size_equals",
+    min_length = "min_length",
+    max_length = "max_length",
+    length_equals = "length_equals",
+    string_format = "string_format",
+    regex = "regex"
+}
+export declare const MetaCheckTypeList: {
+    key: string;
+    value: MetaCheckType;
+}[];
+export interface MetaChecks {
+    [MetaCheckType.bigint_format]?: $ZodCheckBigIntFormatDef;
+    [MetaCheckType.less_than]?: $ZodCheckLessThanDef;
+    [MetaCheckType.greater_than]?: $ZodCheckGreaterThanDef;
+    [MetaCheckType.multiple_of]?: $ZodCheckMultipleOfDef;
+    [MetaCheckType.number_format]?: $ZodCheckNumberFormatDef;
+    [MetaCheckType.min_size]?: $ZodCheckMinSizeDef;
+    [MetaCheckType.max_size]?: $ZodCheckMaxSizeDef;
+    [MetaCheckType.size_equals]?: $ZodCheckSizeEqualsDef;
+    [MetaCheckType.min_length]?: $ZodCheckMinLengthDef;
+    [MetaCheckType.max_length]?: $ZodCheckMaxLengthDef;
+    [MetaCheckType.length_equals]?: $ZodCheckLengthEqualsDef;
+    [MetaCheckType.string_format]?: $ZodCheckStringFormatDef;
+    [MetaCheckType.regex]?: $ZodCheckRegexDef;
+}
+export interface MetaBase {
+    type: MetaType;
+    name: string;
+    title?: string;
+    description?: string;
+    optional?: boolean;
+}
+export interface MetaString extends MetaBase {
+    type: MetaType.string;
+    minLength?: number;
+    maxLength?: number;
+    exactLength?: number;
+    regex?: string;
+    format?: $ZodStringFormats | string;
+}
+export interface MetaBool extends MetaBase {
+    type: MetaType.boolean;
+}
+export interface MetaNumber extends MetaBase {
+    type: MetaType.number;
+    minValue?: number;
+    minInclusive?: boolean;
+    maxValue?: number;
+    maxInclusive?: boolean;
+    multipleOf?: number;
+    format?: $ZodNumberFormats;
+}
+export interface MetaInt extends MetaBase {
+    type: MetaType.int;
+    minValue?: number;
+    minInclusive?: boolean;
+    maxValue?: number;
+    maxInclusive?: boolean;
+    multipleOf?: number;
+    format?: $ZodNumberFormats;
+}
+export interface MetaDate extends MetaBase {
+    type: MetaType.date;
+}
+export interface MetaArray extends MetaBase {
+    type: MetaType.array;
+    item: MetaItem;
+    minLength?: number;
+    maxLength?: number;
+    exactLength?: number;
+}
+export interface MetaRecord extends MetaBase {
+    type: MetaType.record;
+    keyType: MetaItem;
+    valueType: MetaItem;
+}
+export interface MetaObject extends MetaBase {
+    type: MetaType.object;
+    properties: MetaItem | MetaItem[];
+}
+export interface MetaEnumEntry {
+    key: string;
+    value: number | string;
+    title?: string;
+}
+export interface MetaEnumEntryTitle {
+    value: string;
+    title?: string;
+}
+export interface MetaEnum extends MetaBase {
+    type: MetaType.enum;
+    entries: MetaEnumEntry[];
+}
+export interface MetaOptional extends MetaBase {
+    type: MetaType.record;
+    inner: MetaItem;
+}
+export interface MetaItem {
+    boolean?: MetaBool;
+    string?: MetaString;
+    number?: MetaNumber;
+    int?: MetaInt;
+    date?: MetaDate;
+    array?: MetaArray;
+    record?: MetaRecord;
+    object?: MetaObject;
+    enum?: MetaEnum;
+}
+export type MetaFunc = (name: string, prop: $ZodType, optional?: boolean) => MetaItem | undefined;
+export type MetaFuncs = {
+    [key in MetaType | MetaInternalType]: MetaFunc;
+};

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@mxpicture/zod-meta",
+  "version": "0.1.0",
+  "description": "Zod Metadata Extraction, publishing both CommonJS and ESM builds",
+  "author": "MXPicture",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MXPicture/node-library-zod-meta"
+  },
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/types/package.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/package.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist/"
+  ],
+  "engines": {
+    "node": "24"
+  },
+  "scripts": {
+    "commit": "git-cz",
+    "prepare": "husky install && npm run build",
+    "clean": "rm -rf dist .tsbuildinfo",
+    "build:types": "tsc -p tsconfig.types.json",
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "build:esm": "tsc -p tsconfig.esm.json",
+    "build": "npm run clean && npm run build:types && npm run build:cjs && npm run build:esm",
+    "lint": "eslint \"src/**/*.{ts,tsx}\" --ext .ts,.tsx",
+    "update": "ncu -u && npm install"
+  },
+  "config": {
+    "commitizen": {
+      "path": "./node_modules/cz-conventional-changelog"
+    }
+  },
+  "dependencies": {
+    "zod": "^4.3.5"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^20.3.1",
+    "@commitlint/config-conventional": "^20.3.1",
+    "@eslint/compat": "^2.0.1",
+    "@types/node": "^25.0.9",
+    "@typescript-eslint/eslint-plugin": "^8.53.1",
+    "@typescript-eslint/parser": "^8.53.1",
+    "commitizen": "^4.3.1",
+    "cz-conventional-changelog": "^3.3.0",
+    "eslint": "^9.39.2",
+    "eslint-config-google": "^0.14.0",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-tsdoc": "^0.5.0",
+    "husky": "^8.0.0",
+    "typescript": "^5.9.3"
+  }
+}