@highstate/designer 0.19.1 → 0.21.1

package/.output/server/node_modules/zod/v4/locales/it.js

@@ -9,27 +9,7 @@ const error = () => {
     function getSizing(origin) {
         return Sizable[origin] ?? null;
     }
-    const parsedType = (data) => {
-        const t = typeof data;
-        switch (t) {
-            case "number": {
-                return Number.isNaN(data) ? "NaN" : "numero";
-            }
-            case "object": {
-                if (Array.isArray(data)) {
-                    return "vettore";
-                }
-                if (data === null) {
-                    return "null";
-                }
-                if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-                    return data.constructor.name;
-                }
-            }
-        }
-        return t;
-    };
-    const Nouns = {
+    const FormatDictionary = {
         regex: "input",
         email: "indirizzo email",
         url: "URL",
@@ -59,11 +39,22 @@ const error = () => {
         jwt: "JWT",
         template_literal: "input",
     };
+    const TypeDictionary = {
+        nan: "NaN",
+        number: "numero",
+        array: "vettore",
+    };
     return (issue) => {
         switch (issue.code) {
-            case "invalid_type":
-                return `Input non valido: atteso ${issue.expected}, ricevuto ${parsedType(issue.input)}`;
-            // return `Input non valido: atteso ${issue.expected}, ricevuto ${util.getParsedType(issue.input)}`;
+            case "invalid_type": {
+                const expected = TypeDictionary[issue.expected] ?? issue.expected;
+                const receivedType = util.parsedType(issue.input);
+                const received = TypeDictionary[receivedType] ?? receivedType;
+                if (/^[A-Z]/.test(issue.expected)) {
+                    return `Input non valido: atteso instanceof ${issue.expected}, ricevuto ${received}`;
+                }
+                return `Input non valido: atteso ${expected}, ricevuto ${received}`;
+            }
             case "invalid_value":
                 if (issue.values.length === 1)
                     return `Input non valido: atteso ${util.stringifyPrimitive(issue.values[0])}`;
@@ -93,7 +84,7 @@ const error = () => {
                     return `Stringa non valida: deve includere "${_issue.includes}"`;
                 if (_issue.format === "regex")
                     return `Stringa non valida: deve corrispondere al pattern ${_issue.pattern}`;
-                return `Invalid ${Nouns[_issue.format] ?? issue.format}`;
+                return `Invalid ${FormatDictionary[_issue.format] ?? issue.format}`;
             }
             case "not_multiple_of":
                 return `Numero non valido: deve essere un multiplo di ${issue.divisor}`;

package/.output/server/node_modules/zod/v4/locales/ja.js

@@ -9,27 +9,7 @@ const error = () => {
     function getSizing(origin) {
         return Sizable[origin] ?? null;
     }
-    const parsedType = (data) => {
-        const t = typeof data;
-        switch (t) {
-            case "number": {
-                return Number.isNaN(data) ? "NaN" : "数値";
-            }
-            case "object": {
-                if (Array.isArray(data)) {
-                    return "配列";
-                }
-                if (data === null) {
-                    return "null";
-                }
-                if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-                    return data.constructor.name;
-                }
-            }
-        }
-        return t;
-    };
-    const Nouns = {
+    const FormatDictionary = {
         regex: "入力値",
         email: "メールアドレス",
         url: "URL",
@@ -59,10 +39,22 @@ const error = () => {
         jwt: "JWT",
         template_literal: "入力値",
     };
+    const TypeDictionary = {
+        nan: "NaN",
+        number: "数値",
+        array: "配列",
+    };
     return (issue) => {
         switch (issue.code) {
-            case "invalid_type":
-                return `無効な入力: ${issue.expected}が期待されましたが、${parsedType(issue.input)}が入力されました`;
+            case "invalid_type": {
+                const expected = TypeDictionary[issue.expected] ?? issue.expected;
+                const receivedType = util.parsedType(issue.input);
+                const received = TypeDictionary[receivedType] ?? receivedType;
+                if (/^[A-Z]/.test(issue.expected)) {
+                    return `無効な入力: instanceof ${issue.expected}が期待されましたが、${received}が入力されました`;
+                }
+                return `無効な入力: ${expected}が期待されましたが、${received}が入力されました`;
+            }
             case "invalid_value":
                 if (issue.values.length === 1)
                     return `無効な入力: ${util.stringifyPrimitive(issue.values[0])}が期待されました`;
@@ -91,7 +83,7 @@ const error = () => {
                     return `無効な文字列: "${_issue.includes}"を含む必要があります`;
                 if (_issue.format === "regex")
                     return `無効な文字列: パターン${_issue.pattern}に一致する必要があります`;
-                return `無効な${Nouns[_issue.format] ?? issue.format}`;
+                return `無効な${FormatDictionary[_issue.format] ?? issue.format}`;
             }
             case "not_multiple_of":
                 return `無効な数値: ${issue.divisor}の倍数である必要があります`;

package/.output/server/node_modules/zod/v4/locales/ka.js

@@ -1,32 +1,4 @@
 import * as util from "../core/util.js";
-export const parsedType = (data) => {
-    const t = typeof data;
-    switch (t) {
-        case "number": {
-            return Number.isNaN(data) ? "NaN" : "რიცხვი";
-        }
-        case "object": {
-            if (Array.isArray(data)) {
-                return "მასივი";
-            }
-            if (data === null) {
-                return "null";
-            }
-            if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-                return data.constructor.name;
-            }
-        }
-    }
-    const typeMap = {
-        string: "სტრინგი",
-        boolean: "ბულეანი",
-        undefined: "undefined",
-        bigint: "bigint",
-        symbol: "symbol",
-        function: "ფუნქცია",
-    };
-    return typeMap[t] ?? t;
-};
 const error = () => {
     const Sizable = {
         string: { unit: "სიმბოლო", verb: "უნდა შეიცავდეს" },
@@ -37,7 +9,7 @@ const error = () => {
     function getSizing(origin) {
         return Sizable[origin] ?? null;
     }
-    const Nouns = {
+    const FormatDictionary = {
         regex: "შეყვანა",
         email: "ელ-ფოსტის მისამართი",
         url: "URL",
@@ -67,10 +39,25 @@ const error = () => {
         jwt: "JWT",
         template_literal: "შეყვანა",
     };
+    const TypeDictionary = {
+        nan: "NaN",
+        number: "რიცხვი",
+        string: "სტრინგი",
+        boolean: "ბულეანი",
+        function: "ფუნქცია",
+        array: "მასივი",
+    };
     return (issue) => {
         switch (issue.code) {
-            case "invalid_type":
-                return `არასწორი შეყვანა: მოსალოდნელი ${issue.expected}, მიღებული ${parsedType(issue.input)}`;
+            case "invalid_type": {
+                const expected = TypeDictionary[issue.expected] ?? issue.expected;
+                const receivedType = util.parsedType(issue.input);
+                const received = TypeDictionary[receivedType] ?? receivedType;
+                if (/^[A-Z]/.test(issue.expected)) {
+                    return `არასწორი შეყვანა: მოსალოდნელი instanceof ${issue.expected}, მიღებული ${received}`;
+                }
+                return `არასწორი შეყვანა: მოსალოდნელი ${expected}, მიღებული ${received}`;
+            }
             case "invalid_value":
                 if (issue.values.length === 1)
                     return `არასწორი შეყვანა: მოსალოდნელი ${util.stringifyPrimitive(issue.values[0])}`;
@@ -101,7 +88,7 @@ const error = () => {
                     return `არასწორი სტრინგი: უნდა შეიცავდეს "${_issue.includes}"-ს`;
                 if (_issue.format === "regex")
                     return `არასწორი სტრინგი: უნდა შეესაბამებოდეს შაბლონს ${_issue.pattern}`;
-                return `არასწორი ${Nouns[_issue.format] ?? issue.format}`;
+                return `არასწორი ${FormatDictionary[_issue.format] ?? issue.format}`;
             }
             case "not_multiple_of":
                 return `არასწორი რიცხვი: უნდა იყოს ${issue.divisor}-ის ჯერადი`;

package/.output/server/node_modules/zod/v4/locales/km.js

@@ -9,27 +9,7 @@ const error = () => {
     function getSizing(origin) {
         return Sizable[origin] ?? null;
     }
-    const parsedType = (data) => {
-        const t = typeof data;
-        switch (t) {
-            case "number": {
-                return Number.isNaN(data) ? "មិនមែនជាលេខ (NaN)" : "លេខ";
-            }
-            case "object": {
-                if (Array.isArray(data)) {
-                    return "អារេ (Array)";
-                }
-                if (data === null) {
-                    return "គ្មានតម្លៃ (null)";
-                }
-                if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-                    return data.constructor.name;
-                }
-            }
-        }
-        return t;
-    };
-    const Nouns = {
+    const FormatDictionary = {
         regex: "ទិន្នន័យបញ្ចូល",
         email: "អាសយដ្ឋានអ៊ីមែល",
         url: "URL",
@@ -59,10 +39,23 @@ const error = () => {
         jwt: "JWT",
         template_literal: "ទិន្នន័យបញ្ចូល",
     };
+    const TypeDictionary = {
+        nan: "NaN",
+        number: "លេខ",
+        array: "អារេ (Array)",
+        null: "គ្មានតម្លៃ (null)",
+    };
     return (issue) => {
         switch (issue.code) {
-            case "invalid_type":
-                return `ទិន្នន័យបញ្ចូលមិនត្រឹមត្រូវ៖ ត្រូវការ ${issue.expected} ប៉ុន្តែទទួលបាន ${parsedType(issue.input)}`;
+            case "invalid_type": {
+                const expected = TypeDictionary[issue.expected] ?? issue.expected;
+                const receivedType = util.parsedType(issue.input);
+                const received = TypeDictionary[receivedType] ?? receivedType;
+                if (/^[A-Z]/.test(issue.expected)) {
+                    return `ទិន្នន័យបញ្ចូលមិនត្រឹមត្រូវ៖ ត្រូវការ instanceof ${issue.expected} ប៉ុន្តែទទួលបាន ${received}`;
+                }
+                return `ទិន្នន័យបញ្ចូលមិនត្រឹមត្រូវ៖ ត្រូវការ ${expected} ប៉ុន្តែទទួលបាន ${received}`;
+            }
             case "invalid_value":
                 if (issue.values.length === 1)
                     return `ទិន្នន័យបញ្ចូលមិនត្រឹមត្រូវ៖ ត្រូវការ ${util.stringifyPrimitive(issue.values[0])}`;
@@ -93,7 +86,7 @@ const error = () => {
                     return `ខ្សែអក្សរមិនត្រឹមត្រូវ៖ ត្រូវមាន "${_issue.includes}"`;
                 if (_issue.format === "regex")
                     return `ខ្សែអក្សរមិនត្រឹមត្រូវ៖ ត្រូវតែផ្គូផ្គងនឹងទម្រង់ដែលបានកំណត់ ${_issue.pattern}`;
-                return `មិនត្រឹមត្រូវ៖ ${Nouns[_issue.format] ?? issue.format}`;
+                return `មិនត្រឹមត្រូវ៖ ${FormatDictionary[_issue.format] ?? issue.format}`;
             }
             case "not_multiple_of":
                 return `លេខមិនត្រឹមត្រូវ៖ ត្រូវតែជាពហុគុណនៃ ${issue.divisor}`;

package/.output/server/node_modules/zod/v4/locales/ko.js

@@ -9,27 +9,7 @@ const error = () => {
     function getSizing(origin) {
         return Sizable[origin] ?? null;
     }
-    const parsedType = (data) => {
-        const t = typeof data;
-        switch (t) {
-            case "number": {
-                return Number.isNaN(data) ? "NaN" : "number";
-            }
-            case "object": {
-                if (Array.isArray(data)) {
-                    return "array";
-                }
-                if (data === null) {
-                    return "null";
-                }
-                if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-                    return data.constructor.name;
-                }
-            }
-        }
-        return t;
-    };
-    const Nouns = {
+    const FormatDictionary = {
         regex: "입력",
         email: "이메일 주소",
         url: "URL",
@@ -59,10 +39,20 @@ const error = () => {
         jwt: "JWT",
         template_literal: "입력",
     };
+    const TypeDictionary = {
+        nan: "NaN",
+    };
     return (issue) => {
         switch (issue.code) {
-            case "invalid_type":
-                return `잘못된 입력: 예상 타입은 ${issue.expected}, 받은 타입은 ${parsedType(issue.input)}입니다`;
+            case "invalid_type": {
+                const expected = TypeDictionary[issue.expected] ?? issue.expected;
+                const receivedType = util.parsedType(issue.input);
+                const received = TypeDictionary[receivedType] ?? receivedType;
+                if (/^[A-Z]/.test(issue.expected)) {
+                    return `잘못된 입력: 예상 타입은 instanceof ${issue.expected}, 받은 타입은 ${received}입니다`;
+                }
+                return `잘못된 입력: 예상 타입은 ${expected}, 받은 타입은 ${received}입니다`;
+            }
             case "invalid_value":
                 if (issue.values.length === 1)
                     return `잘못된 입력: 값은 ${util.stringifyPrimitive(issue.values[0])} 이어야 합니다`;
@@ -97,7 +87,7 @@ const error = () => {
                     return `잘못된 문자열: "${_issue.includes}"을(를) 포함해야 합니다`;
                 if (_issue.format === "regex")
                     return `잘못된 문자열: 정규식 ${_issue.pattern} 패턴과 일치해야 합니다`;
-                return `잘못된 ${Nouns[_issue.format] ?? issue.format}`;
+                return `잘못된 ${FormatDictionary[_issue.format] ?? issue.format}`;
             }
             case "not_multiple_of":
                 return `잘못된 숫자: ${issue.divisor}의 배수여야 합니다`;

package/.output/server/node_modules/zod/v4/locales/lt.js

@@ -1,51 +1,4 @@
 import * as util from "../core/util.js";
-export const parsedType = (data) => {
-    const t = typeof data;
-    return parsedTypeFromType(t, data);
-};
-const parsedTypeFromType = (t, data = undefined) => {
-    switch (t) {
-        case "number": {
-            return Number.isNaN(data) ? "NaN" : "skaičius";
-        }
-        case "bigint": {
-            return "sveikasis skaičius";
-        }
-        case "string": {
-            return "eilutė";
-        }
-        case "boolean": {
-            return "loginė reikšmė";
-        }
-        case "undefined":
-        case "void": {
-            return "neapibrėžta reikšmė";
-        }
-        case "function": {
-            return "funkcija";
-        }
-        case "symbol": {
-            return "simbolis";
-        }
-        case "object": {
-            if (data === undefined)
-                return "nežinomas objektas";
-            if (data === null)
-                return "nulinė reikšmė";
-            if (Array.isArray(data))
-                return "masyvas";
-            if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-                return data.constructor.name;
-            }
-            return "objektas";
-        }
-        //Zod types below
-        case "null": {
-            return "nulinė reikšmė";
-        }
-    }
-    return t;
-};
 const capitalizeFirstCharacter = (text) => {
     return text.charAt(0).toUpperCase() + text.slice(1);
 };
@@ -139,7 +92,7 @@ const error = () => {
             verb: result.verb[targetShouldBe][inclusive ? "inclusive" : "notInclusive"],
         };
     }
-    const Nouns = {
+    const FormatDictionary = {
         regex: "įvestis",
         email: "el. pašto adresas",
         url: "URL",
@@ -169,16 +122,36 @@ const error = () => {
         jwt: "JWT",
         template_literal: "įvestis",
     };
+    const TypeDictionary = {
+        nan: "NaN",
+        number: "skaičius",
+        bigint: "sveikasis skaičius",
+        string: "eilutė",
+        boolean: "loginė reikšmė",
+        undefined: "neapibrėžta reikšmė",
+        function: "funkcija",
+        symbol: "simbolis",
+        array: "masyvas",
+        object: "objektas",
+        null: "nulinė reikšmė",
+    };
     return (issue) => {
         switch (issue.code) {
-            case "invalid_type":
-                return `Gautas tipas ${parsedType(issue.input)}, o tikėtasi - ${parsedTypeFromType(issue.expected)}`;
+            case "invalid_type": {
+                const expected = TypeDictionary[issue.expected] ?? issue.expected;
+                const receivedType = util.parsedType(issue.input);
+                const received = TypeDictionary[receivedType] ?? receivedType;
+                if (/^[A-Z]/.test(issue.expected)) {
+                    return `Gautas tipas ${received}, o tikėtasi - instanceof ${issue.expected}`;
+                }
+                return `Gautas tipas ${received}, o tikėtasi - ${expected}`;
+            }
             case "invalid_value":
                 if (issue.values.length === 1)
                     return `Privalo būti ${util.stringifyPrimitive(issue.values[0])}`;
                 return `Privalo būti vienas iš ${util.joinValues(issue.values, "|")} pasirinkimų`;
             case "too_big": {
-                const origin = parsedTypeFromType(issue.origin);
+                const origin = TypeDictionary[issue.origin] ?? issue.origin;
                 const sizing = getSizing(issue.origin, getUnitTypeFromNumber(Number(issue.maximum)), issue.inclusive ?? false, "smaller");
                 if (sizing?.verb)
                     return `${capitalizeFirstCharacter(origin ?? issue.origin ?? "reikšmė")} ${sizing.verb} ${issue.maximum.toString()} ${sizing.unit ?? "elementų"}`;
@@ -186,7 +159,7 @@ const error = () => {
                 return `${capitalizeFirstCharacter(origin ?? issue.origin ?? "reikšmė")} turi būti ${adj} ${issue.maximum.toString()} ${sizing?.unit}`;
             }
             case "too_small": {
-                const origin = parsedTypeFromType(issue.origin);
+                const origin = TypeDictionary[issue.origin] ?? issue.origin;
                 const sizing = getSizing(issue.origin, getUnitTypeFromNumber(Number(issue.minimum)), issue.inclusive ?? false, "bigger");
                 if (sizing?.verb)
                     return `${capitalizeFirstCharacter(origin ?? issue.origin ?? "reikšmė")} ${sizing.verb} ${issue.minimum.toString()} ${sizing.unit ?? "elementų"}`;
@@ -204,7 +177,7 @@ const error = () => {
                     return `Eilutė privalo įtraukti "${_issue.includes}"`;
                 if (_issue.format === "regex")
                     return `Eilutė privalo atitikti ${_issue.pattern}`;
-                return `Neteisingas ${Nouns[_issue.format] ?? issue.format}`;
+                return `Neteisingas ${FormatDictionary[_issue.format] ?? issue.format}`;
             }
             case "not_multiple_of":
                 return `Skaičius privalo būti ${issue.divisor} kartotinis.`;
@@ -215,7 +188,7 @@ const error = () => {
             case "invalid_union":
                 return "Klaidinga įvestis";
             case "invalid_element": {
-                const origin = parsedTypeFromType(issue.origin);
+                const origin = TypeDictionary[issue.origin] ?? issue.origin;
                 return `${capitalizeFirstCharacter(origin ?? issue.origin ?? "reikšmė")} turi klaidingą įvestį`;
             }
             default:

package/.output/server/node_modules/zod/v4/locales/mk.js

@@ -9,27 +9,7 @@ const error = () => {
     function getSizing(origin) {
         return Sizable[origin] ?? null;
     }
-    const parsedType = (data) => {
-        const t = typeof data;
-        switch (t) {
-            case "number": {
-                return Number.isNaN(data) ? "NaN" : "број";
-            }
-            case "object": {
-                if (Array.isArray(data)) {
-                    return "низа";
-                }
-                if (data === null) {
-                    return "null";
-                }
-                if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-                    return data.constructor.name;
-                }
-            }
-        }
-        return t;
-    };
-    const Nouns = {
+    const FormatDictionary = {
         regex: "внес",
         email: "адреса на е-пошта",
         url: "URL",
@@ -59,11 +39,22 @@ const error = () => {
         jwt: "JWT",
         template_literal: "внес",
     };
+    const TypeDictionary = {
+        nan: "NaN",
+        number: "број",
+        array: "низа",
+    };
     return (issue) => {
         switch (issue.code) {
-            case "invalid_type":
-                return `Грешен внес: се очекува ${issue.expected}, примено ${parsedType(issue.input)}`;
-            // return `Invalid input: expected ${issue.expected}, received ${util.getParsedType(issue.input)}`;
+            case "invalid_type": {
+                const expected = TypeDictionary[issue.expected] ?? issue.expected;
+                const receivedType = util.parsedType(issue.input);
+                const received = TypeDictionary[receivedType] ?? receivedType;
+                if (/^[A-Z]/.test(issue.expected)) {
+                    return `Грешен внес: се очекува instanceof ${issue.expected}, примено ${received}`;
+                }
+                return `Грешен внес: се очекува ${expected}, примено ${received}`;
+            }
             case "invalid_value":
                 if (issue.values.length === 1)
                     return `Invalid input: expected ${util.stringifyPrimitive(issue.values[0])}`;
@@ -94,7 +85,7 @@ const error = () => {
                     return `Неважечка низа: мора да вклучува "${_issue.includes}"`;
                 if (_issue.format === "regex")
                     return `Неважечка низа: мора да одгоара на патернот ${_issue.pattern}`;
-                return `Invalid ${Nouns[_issue.format] ?? issue.format}`;
+                return `Invalid ${FormatDictionary[_issue.format] ?? issue.format}`;
             }
             case "not_multiple_of":
                 return `Грешен број: мора да биде делив со ${issue.divisor}`;

package/.output/server/node_modules/zod/v4/locales/ms.js

@@ -9,27 +9,7 @@ const error = () => {
     function getSizing(origin) {
         return Sizable[origin] ?? null;
     }
-    const parsedType = (data) => {
-        const t = typeof data;
-        switch (t) {
-            case "number": {
-                return Number.isNaN(data) ? "NaN" : "nombor";
-            }
-            case "object": {
-                if (Array.isArray(data)) {
-                    return "array";
-                }
-                if (data === null) {
-                    return "null";
-                }
-                if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-                    return data.constructor.name;
-                }
-            }
-        }
-        return t;
-    };
-    const Nouns = {
+    const FormatDictionary = {
         regex: "input",
         email: "alamat e-mel",
         url: "URL",
@@ -59,10 +39,21 @@ const error = () => {
         jwt: "JWT",
         template_literal: "input",
     };
+    const TypeDictionary = {
+        nan: "NaN",
+        number: "nombor",
+    };
     return (issue) => {
         switch (issue.code) {
-            case "invalid_type":
-                return `Input tidak sah: dijangka ${issue.expected}, diterima ${parsedType(issue.input)}`;
+            case "invalid_type": {
+                const expected = TypeDictionary[issue.expected] ?? issue.expected;
+                const receivedType = util.parsedType(issue.input);
+                const received = TypeDictionary[receivedType] ?? receivedType;
+                if (/^[A-Z]/.test(issue.expected)) {
+                    return `Input tidak sah: dijangka instanceof ${issue.expected}, diterima ${received}`;
+                }
+                return `Input tidak sah: dijangka ${expected}, diterima ${received}`;
+            }
             case "invalid_value":
                 if (issue.values.length === 1)
                     return `Input tidak sah: dijangka ${util.stringifyPrimitive(issue.values[0])}`;
@@ -92,7 +83,7 @@ const error = () => {
                     return `String tidak sah: mesti mengandungi "${_issue.includes}"`;
                 if (_issue.format === "regex")
                     return `String tidak sah: mesti sepadan dengan corak ${_issue.pattern}`;
-                return `${Nouns[_issue.format] ?? issue.format} tidak sah`;
+                return `${FormatDictionary[_issue.format] ?? issue.format} tidak sah`;
             }
             case "not_multiple_of":
                 return `Nombor tidak sah: perlu gandaan ${issue.divisor}`;