libshv-js 3.17.0 → 3.20.0

package/dist/zod.js

@@ -0,0 +1,112 @@
+"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 });
+exports.withMeta = exports.rpcvalue = exports.list = exports.blob = exports.decimal = exports.double = exports.uint = exports.recmap = exports.metamap = exports.imap = exports.map = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const v4_1 = require("zod/v4");
+const rpcvalue_1 = require("./rpcvalue");
+const implMakeMapParser = (mapValidator, _mapBrand, mapName, objectParser) => v4_1.z.custom().check(ctx => {
+    if (!mapValidator(ctx.value)) {
+        ctx.issues.push({
+            expected: 'map',
+            code: 'invalid_type',
+            input: ctx.value,
+            message: `Invalid input: expected ${mapName}, received ${(0, rpcvalue_1.typeName)(ctx.value)}`,
+        });
+        return;
+    }
+    // For record, Zod finds out map brand, and calls the record's value parser with the value. There's no way to detect
+    // it, because Zod does not supply the parser with the key. To prevent this, remove the key before passing the value
+    // to Zod. This unfortunately means that we need to copy the whole object. :/
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { [rpcvalue_1.shvMapType]: zodMustNotHaveThis, ...rest } = { ...ctx.value };
+    const parsedObject = objectParser.safeParse(rest);
+    if (!parsedObject.success) {
+        ctx.issues = parsedObject.error.issues;
+    }
+});
+const map = (schema) => implMakeMapParser(rpcvalue_1.isShvMap, 'map', 'ShvMap', v4_1.z.object(schema));
+exports.map = map;
+const imap = (schema) => implMakeMapParser(rpcvalue_1.isIMap, 'imap', 'IMap', v4_1.z.object(schema));
+exports.imap = imap;
+const metamap = (schema) => implMakeMapParser(rpcvalue_1.isMetaMap, 'metamap', 'MetaMap', v4_1.z.object(schema));
+exports.metamap = metamap;
+const recmap = (schema) => implMakeMapParser(val => (0, rpcvalue_1.isShvMap)(val) || (0, rpcvalue_1.isIMap)(val), 'map', 'ShvMap', v4_1.z.record(v4_1.z.any(), schema));
+exports.recmap = recmap;
+const uint = () => v4_1.z.instanceof((rpcvalue_1.UInt));
+exports.uint = uint;
+const double = () => v4_1.z.instanceof(rpcvalue_1.Double);
+exports.double = double;
+const decimal = () => v4_1.z.instanceof(rpcvalue_1.Decimal);
+exports.decimal = decimal;
+const blob = () => v4_1.z.instanceof(ArrayBuffer);
+exports.blob = blob;
+const list = () => v4_1.z.array(v4_1.z.lazy(exports.rpcvalue));
+exports.list = list;
+const withMetaInstanceParser = v4_1.z.instanceof(rpcvalue_1.RpcValueWithMetaData);
+const rpcvalue = () => v4_1.z.lazy(() => v4_1.z.union([
+    v4_1.z.undefined(),
+    v4_1.z.boolean(),
+    v4_1.z.number(),
+    (0, exports.uint)(),
+    (0, exports.double)(),
+    (0, exports.decimal)(),
+    (0, exports.blob)(),
+    v4_1.z.string(),
+    v4_1.z.date(),
+    (0, exports.list)(),
+    (0, exports.recmap)((0, exports.rpcvalue)()),
+    withMetaInstanceParser,
+]));
+exports.rpcvalue = rpcvalue;
+const withMeta = (metaParser, valueParser) => v4_1.z.custom().check(ctx => {
+    if (!withMetaInstanceParser.safeParse(ctx.value).success) {
+        ctx.issues.push({
+            expected: 'map',
+            code: 'invalid_type',
+            input: ctx.value,
+            message: 'Invalid input: expected a value with metadata, got a value with no metadata}',
+        });
+        return;
+    }
+    const parsedMeta = metaParser.safeParse(ctx.value.meta);
+    if (!parsedMeta.success) {
+        ctx.issues = [
+            {
+                expected: 'map',
+                code: 'invalid_type',
+                input: ctx.value,
+                message: 'Wrong RpcValueWithMetaData meta',
+            },
+            ...parsedMeta.error.issues,
+        ];
+        return;
+    }
+    const parsedValue = valueParser.safeParse(ctx.value.value);
+    if (!parsedValue.success) {
+        ctx.issues = [
+            {
+                expected: 'map',
+                code: 'invalid_type',
+                input: ctx.value,
+                message: 'Wrong RpcValueWithMetaData value',
+            },
+            ...parsedValue.error.issues,
+        ];
+    }
+});
+exports.withMeta = withMeta;
+__exportStar(require("zod/v4"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libshv-js",
-  "version": "3.17.0",
+  "version": "3.20.0",
   "description": "Typescript implementation of libshv",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",