@gershy/util-codec-parse 0.0.4 → 0.0.6

package/cmp/cjs/main.d.ts

@@ -1,4 +1,3 @@
-import '../sideEffects.js';
 import '@gershy/clearing';
 export declare namespace Codec {
     type Base = {

package/cmp/cjs/main.js

@@ -1,115 +1,124 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-require("@gershy/clearing");
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var main_exports = {};
+__export(main_exports, {
+  default: () => main_default
+});
+module.exports = __toCommonJS(main_exports);
+var import_clearing = require("@gershy/clearing");
 ;
-exports.default = (codec, val) => {
-    const assert = (args) => {
-        try {
-            if (!args.fn(args.args))
-                throw Error('assert failed');
-        }
-        catch (err) {
-            throw err[cl.mod]({ codecParse: true, ...args });
-        }
-    };
-    const parse = (codec, val, chain, ctx) => {
-        const checked = (() => {
-            if (codec.type === 'bln') {
-                assert({ desc: 'bln', chain, ctx, args: val, fn: val => cl.isCls(val, Boolean) });
-                return val;
-            }
-            else if (codec.type === 'num') {
-                assert({ desc: 'num', chain, ctx, args: val, fn: val => cl.isCls(val, Number) });
-                return val;
-            }
-            else if (codec.type === 'str') {
-                const { minLen = 0, maxLen = Number[cl.int64] } = codec;
-                assert({
-                    desc: 'str', chain, ctx,
-                    args: { val, minLen, maxLen },
-                    fn: ({ val, minLen, maxLen }) => true
-                        && cl.isCls(val, String)
-                        && val.length >= minLen
-                        && val.length <= maxLen,
-                });
-                return val;
-            }
-            else if (codec.type === 'arr') {
-                const { minLen = 0, maxLen = Number[cl.int64], item } = codec;
-                assert({
-                    desc: 'arr', chain, ctx,
-                    args: { val, minLen, maxLen },
-                    fn: ({ val, minLen, maxLen }) => true
-                        && cl.isCls(val, Array)
-                        && val.length >= minLen
-                        && val.length <= maxLen
-                });
-                return val[cl.map]((v, i) => parse(item, v, [...chain, i.toString(10)], ctx));
-            }
-            else if (codec.type === 'enum') {
-                const { opts } = codec;
-                assert({
-                    desc: 'enum', chain, ctx,
-                    args: { val, opts },
-                    fn: ({ val, opts }) => opts.includes(val)
-                });
-                return val;
-            }
-            else if (codec.type === 'map') {
-                const { item } = codec;
-                assert({
-                    desc: 'map', chain, ctx,
-                    args: val,
-                    fn: val => cl.isCls(val, Object)
-                });
-                return val[cl.map]((v, k) => parse(item, v, [...chain, k], ctx));
-            }
-            else if (codec.type === 'rec') {
-                const { props } = codec;
-                assert({
-                    desc: 'rec', chain, ctx,
-                    args: { val, keys: props[cl.toArr]((v, k) => k) },
-                    fn: ({ val, keys }) => true
-                        && cl.isCls(val, Object)
-                        && val[cl.count]() === keys[cl.count]()
-                        && keys.every(k => val[cl.has](k))
-                });
-                return val[cl.map]((v, k) => parse(props[k], v, [...chain, k], ctx));
-            }
-            else if (codec.type === 'oneOf') {
-                const { opts } = codec;
-                const { result, opt } = (() => {
-                    const errs = [];
-                    for (const opt of opts) {
-                        try {
-                            const result = parse(opt, val, [...chain, `opt(${opt.type})`], ctx);
-                            return { result, opt };
-                        }
-                        catch (err) {
-                            errs.push(err);
-                        }
-                    }
-                    throw Error('all options failed')[cl.mod]({ codecParse: true, desc: 'oneOf', chain, ctx, args: val, errs });
-                })();
-                return result;
-            }
-            else if (codec.type === 'any') {
-                return val;
-            }
-        })();
-        if (codec.map) {
+var main_default = (codec, val) => {
+  const assert = (args) => {
+    try {
+      if (!args.fn(args.args)) throw Error("assert failed");
+    } catch (err) {
+      throw err[cl.mod]({ codecParse: true, ...args });
+    }
+  };
+  const parse = (codec2, val2, chain, ctx) => {
+    const checked = (() => {
+      if (codec2.type === "bln") {
+        assert({ desc: "bln", chain, ctx, args: val2, fn: (val3) => cl.isCls(val3, Boolean) });
+        return val2;
+      } else if (codec2.type === "num") {
+        assert({ desc: "num", chain, ctx, args: val2, fn: (val3) => cl.isCls(val3, Number) });
+        return val2;
+      } else if (codec2.type === "str") {
+        const { minLen = 0, maxLen = Number[cl.int64] } = codec2;
+        assert({
+          desc: "str",
+          chain,
+          ctx,
+          args: { val: val2, minLen, maxLen },
+          fn: ({ val: val3, minLen: minLen2, maxLen: maxLen2 }) => cl.isCls(val3, String) && val3.length >= minLen2 && val3.length <= maxLen2
+        });
+        return val2;
+      } else if (codec2.type === "arr") {
+        const { minLen = 0, maxLen = Number[cl.int64], item } = codec2;
+        assert({
+          desc: "arr",
+          chain,
+          ctx,
+          args: { val: val2, minLen, maxLen },
+          fn: ({ val: val3, minLen: minLen2, maxLen: maxLen2 }) => cl.isCls(val3, Array) && val3.length >= minLen2 && val3.length <= maxLen2
+        });
+        return val2[cl.map]((v, i) => parse(item, v, [...chain, i.toString(10)], ctx));
+      } else if (codec2.type === "enum") {
+        const { opts } = codec2;
+        assert({
+          desc: "enum",
+          chain,
+          ctx,
+          args: { val: val2, opts },
+          fn: ({ val: val3, opts: opts2 }) => opts2.includes(val3)
+        });
+        return val2;
+      } else if (codec2.type === "map") {
+        const { item } = codec2;
+        assert({
+          desc: "map",
+          chain,
+          ctx,
+          args: val2,
+          fn: (val3) => cl.isCls(val3, Object)
+        });
+        return val2[cl.map]((v, k) => parse(item, v, [...chain, k], ctx));
+      } else if (codec2.type === "rec") {
+        const { props } = codec2;
+        assert({
+          desc: "rec",
+          chain,
+          ctx,
+          args: { val: val2, keys: props[cl.toArr]((v, k) => k) },
+          fn: ({ val: val3, keys }) => cl.isCls(val3, Object) && val3[cl.count]() === keys[cl.count]() && keys.every((k) => val3[cl.has](k))
+        });
+        return val2[cl.map]((v, k) => parse(props[k], v, [...chain, k], ctx));
+      } else if (codec2.type === "oneOf") {
+        const { opts } = codec2;
+        const { result, opt: _opt } = (() => {
+          const errs = [];
+          for (const opt of opts) {
             try {
-                return codec.map(checked);
-            }
-            catch (err) {
-                if (!err.codecParse)
-                    throw err;
-                throw err[cl.mod](msg => ({ msg: `map failed (${msg})`, chain, ctx, fn: codec.map }));
+              const result2 = parse(opt, val2, [...chain, `opt(${opt.type})`], ctx);
+              return { result: result2, opt };
+            } catch (err) {
+              errs.push(err);
             }
-        }
-        else {
-            return checked;
-        }
-    };
-    return parse(codec, val, [], {});
+          }
+          throw Error("all options failed")[cl.mod]({ codecParse: true, desc: "oneOf", chain, ctx, args: val2, errs });
+        })();
+        return result;
+      } else if (codec2.type === "any") {
+        return val2;
+      }
+      if (0) /* @__PURE__ */ ((v) => void 0)();
+    })();
+    if (codec2.map) {
+      try {
+        return codec2.map(checked);
+      } catch (err) {
+        if (!err.codecParse) throw err;
+        throw err[cl.mod]((msg) => ({ msg: `map failed (${msg})`, chain, ctx, fn: codec2.map }));
+      }
+    } else {
+      return checked;
+    }
+  };
+  return parse(codec, val, [], {});
 };

package/cmp/{mjs → esm}/main.d.ts

@@ -1,4 +1,3 @@
-import '../sideEffects.js';
 import '@gershy/clearing';
 export declare namespace Codec {
     type Base = {

package/cmp/esm/main.js

@@ -0,0 +1,104 @@
+import "@gershy/clearing";
+;
+var main_default = (codec, val) => {
+  const assert = (args) => {
+    try {
+      if (!args.fn(args.args)) throw Error("assert failed");
+    } catch (err) {
+      throw err[cl.mod]({ codecParse: true, ...args });
+    }
+  };
+  const parse = (codec2, val2, chain, ctx) => {
+    const checked = (() => {
+      if (codec2.type === "bln") {
+        assert({ desc: "bln", chain, ctx, args: val2, fn: (val3) => cl.isCls(val3, Boolean) });
+        return val2;
+      } else if (codec2.type === "num") {
+        assert({ desc: "num", chain, ctx, args: val2, fn: (val3) => cl.isCls(val3, Number) });
+        return val2;
+      } else if (codec2.type === "str") {
+        const { minLen = 0, maxLen = Number[cl.int64] } = codec2;
+        assert({
+          desc: "str",
+          chain,
+          ctx,
+          args: { val: val2, minLen, maxLen },
+          fn: ({ val: val3, minLen: minLen2, maxLen: maxLen2 }) => cl.isCls(val3, String) && val3.length >= minLen2 && val3.length <= maxLen2
+        });
+        return val2;
+      } else if (codec2.type === "arr") {
+        const { minLen = 0, maxLen = Number[cl.int64], item } = codec2;
+        assert({
+          desc: "arr",
+          chain,
+          ctx,
+          args: { val: val2, minLen, maxLen },
+          fn: ({ val: val3, minLen: minLen2, maxLen: maxLen2 }) => cl.isCls(val3, Array) && val3.length >= minLen2 && val3.length <= maxLen2
+        });
+        return val2[cl.map]((v, i) => parse(item, v, [...chain, i.toString(10)], ctx));
+      } else if (codec2.type === "enum") {
+        const { opts } = codec2;
+        assert({
+          desc: "enum",
+          chain,
+          ctx,
+          args: { val: val2, opts },
+          fn: ({ val: val3, opts: opts2 }) => opts2.includes(val3)
+        });
+        return val2;
+      } else if (codec2.type === "map") {
+        const { item } = codec2;
+        assert({
+          desc: "map",
+          chain,
+          ctx,
+          args: val2,
+          fn: (val3) => cl.isCls(val3, Object)
+        });
+        return val2[cl.map]((v, k) => parse(item, v, [...chain, k], ctx));
+      } else if (codec2.type === "rec") {
+        const { props } = codec2;
+        assert({
+          desc: "rec",
+          chain,
+          ctx,
+          args: { val: val2, keys: props[cl.toArr]((v, k) => k) },
+          fn: ({ val: val3, keys }) => cl.isCls(val3, Object) && val3[cl.count]() === keys[cl.count]() && keys.every((k) => val3[cl.has](k))
+        });
+        return val2[cl.map]((v, k) => parse(props[k], v, [...chain, k], ctx));
+      } else if (codec2.type === "oneOf") {
+        const { opts } = codec2;
+        const { result, opt: _opt } = (() => {
+          const errs = [];
+          for (const opt of opts) {
+            try {
+              const result2 = parse(opt, val2, [...chain, `opt(${opt.type})`], ctx);
+              return { result: result2, opt };
+            } catch (err) {
+              errs.push(err);
+            }
+          }
+          throw Error("all options failed")[cl.mod]({ codecParse: true, desc: "oneOf", chain, ctx, args: val2, errs });
+        })();
+        return result;
+      } else if (codec2.type === "any") {
+        return val2;
+      }
+      if (0) /* @__PURE__ */ ((v) => void 0)();
+    })();
+    if (codec2.map) {
+      try {
+        return codec2.map(checked);
+      } catch (err) {
+        if (!err.codecParse) throw err;
+        throw err[cl.mod]((msg) => ({ msg: `map failed (${msg})`, chain, ctx, fn: codec2.map }));
+      }
+    } else {
+      return checked;
+    }
+  };
+  return parse(codec, val, [], {});
+};
+export {
+  main_default as default
+};

package/cmp/esm/sideEffects.d.ts

@@ -0,0 +1,2 @@
+declare global {}
+export {};

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@gershy/util-codec-parse",
-  "version": "0.0.4",
+  "version": "0.0.6",
+  "author": "Gershom Maes",
   "description": "TODO",
   "keywords": [
     "TODO"
   ],
-  "author": "Gershom Maes",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/gershyNpm/utilCodecParse.git"
@@ -14,36 +14,26 @@
     "url": "https://github.com/gershyNpm/utilCodecParse/issues"
   },
   "homepage": "https://github.com/gershyNpm/utilCodecParse#readme",
+  "type": "module",
+  "files": [
+    "cmp"
+  ],
   "license": "ISC",
   "peerDependencies": {
-    "@gershy/clearing": "^0.0.36"
+    "@gershy/clearing": "^0.0.41"
   },
   "devDependencies": {
-    "@types/node": "^24.10.1",
-    "tsx": "^4.21.0",
-    "typescript": "^5.9.3"
+    "@types/node": "^24.10.1"
   },
   "dependencies": {},
-  "type": "module",
-  "files": [
-    "cmp"
-  ],
-  "sideEffects": false,
-  "types": "./cmp/mjs/main.d.ts",
   "exports": {
     ".": {
-      "import": "./cmp/mjs/main.js",
+      "import": "./cmp/esm/main.js",
       "require": "./cmp/cjs/main.js"
     }
   },
   "scripts": {
     "test": "npm run ts.check && npx tsx ./src/main.test.ts",
-    "ts.check": "npx tsc --noEmit",
-    "build.cjs": "tsc -p build/tsconfig.cjs.json",
-    "build.mjs": "tsc -p build/tsconfig.mjs.json",
-    "build": "node ./build/act.js removeCmp && npm run build.cjs && npm run build.mjs && node ./build/act.js finalizeExportVariants",
-    "git.pub": "npm run test && git add --all && git commit -m \"automated\" && git push",
-    "npm.login": "npm login",
-    "npm.pub": "npm run test && npm run build && npm publish --access public"
+    "ts.check": "npx tsc --noEmit"
   }
 }

package/cmp/mjs/main.js

@@ -1,113 +0,0 @@
-import '@gershy/clearing';
-;
-export default (codec, val) => {
-    const assert = (args) => {
-        try {
-            if (!args.fn(args.args))
-                throw Error('assert failed');
-        }
-        catch (err) {
-            throw err[cl.mod]({ codecParse: true, ...args });
-        }
-    };
-    const parse = (codec, val, chain, ctx) => {
-        const checked = (() => {
-            if (codec.type === 'bln') {
-                assert({ desc: 'bln', chain, ctx, args: val, fn: val => cl.isCls(val, Boolean) });
-                return val;
-            }
-            else if (codec.type === 'num') {
-                assert({ desc: 'num', chain, ctx, args: val, fn: val => cl.isCls(val, Number) });
-                return val;
-            }
-            else if (codec.type === 'str') {
-                const { minLen = 0, maxLen = Number[cl.int64] } = codec;
-                assert({
-                    desc: 'str', chain, ctx,
-                    args: { val, minLen, maxLen },
-                    fn: ({ val, minLen, maxLen }) => true
-                        && cl.isCls(val, String)
-                        && val.length >= minLen
-                        && val.length <= maxLen,
-                });
-                return val;
-            }
-            else if (codec.type === 'arr') {
-                const { minLen = 0, maxLen = Number[cl.int64], item } = codec;
-                assert({
-                    desc: 'arr', chain, ctx,
-                    args: { val, minLen, maxLen },
-                    fn: ({ val, minLen, maxLen }) => true
-                        && cl.isCls(val, Array)
-                        && val.length >= minLen
-                        && val.length <= maxLen
-                });
-                return val[cl.map]((v, i) => parse(item, v, [...chain, i.toString(10)], ctx));
-            }
-            else if (codec.type === 'enum') {
-                const { opts } = codec;
-                assert({
-                    desc: 'enum', chain, ctx,
-                    args: { val, opts },
-                    fn: ({ val, opts }) => opts.includes(val)
-                });
-                return val;
-            }
-            else if (codec.type === 'map') {
-                const { item } = codec;
-                assert({
-                    desc: 'map', chain, ctx,
-                    args: val,
-                    fn: val => cl.isCls(val, Object)
-                });
-                return val[cl.map]((v, k) => parse(item, v, [...chain, k], ctx));
-            }
-            else if (codec.type === 'rec') {
-                const { props } = codec;
-                assert({
-                    desc: 'rec', chain, ctx,
-                    args: { val, keys: props[cl.toArr]((v, k) => k) },
-                    fn: ({ val, keys }) => true
-                        && cl.isCls(val, Object)
-                        && val[cl.count]() === keys[cl.count]()
-                        && keys.every(k => val[cl.has](k))
-                });
-                return val[cl.map]((v, k) => parse(props[k], v, [...chain, k], ctx));
-            }
-            else if (codec.type === 'oneOf') {
-                const { opts } = codec;
-                const { result, opt } = (() => {
-                    const errs = [];
-                    for (const opt of opts) {
-                        try {
-                            const result = parse(opt, val, [...chain, `opt(${opt.type})`], ctx);
-                            return { result, opt };
-                        }
-                        catch (err) {
-                            errs.push(err);
-                        }
-                    }
-                    throw Error('all options failed')[cl.mod]({ codecParse: true, desc: 'oneOf', chain, ctx, args: val, errs });
-                })();
-                return result;
-            }
-            else if (codec.type === 'any') {
-                return val;
-            }
-        })();
-        if (codec.map) {
-            try {
-                return codec.map(checked);
-            }
-            catch (err) {
-                if (!err.codecParse)
-                    throw err;
-                throw err[cl.mod](msg => ({ msg: `map failed (${msg})`, chain, ctx, fn: codec.map }));
-            }
-        }
-        else {
-            return checked;
-        }
-    };
-    return parse(codec, val, [], {});
-};