tsondb 0.1.3

package/lib/server/index.d.ts

@@ -0,0 +1,8 @@
+import { ModelContainer } from "../ModelContainer.js";
+import { InstancesByEntityName } from "../shared/utils/instances.js";
+type ServerOptions = {
+    name: string;
+    port: number;
+};
+export declare const createServer: (modelContainer: ModelContainer, instancesByEntityName: InstancesByEntityName, options?: Partial<ServerOptions>) => void;
+export {};

package/lib/server/index.js

@@ -0,0 +1,207 @@
+import express from "express";
+import { join } from "node:path";
+import { serializeDecl } from "../schema/declarations/Declaration.js";
+import { isEntityDecl, serializeEntityDecl } from "../schema/declarations/EntityDecl.js";
+import { isEnumDecl } from "../schema/declarations/EnumDecl.js";
+import { isTypeAliasDecl } from "../schema/declarations/TypeAliasDecl.js";
+import { getDisplayNameFromEntityInstance } from "../shared/utils/displayName.js";
+import { isOk } from "../utils/result.js";
+import { createInstance, deleteInstance, updateInstance } from "./instanceOperations.js";
+const defaultOptions = {
+    name: "tsondb server",
+    port: 3000,
+};
+export const createServer = (modelContainer, instancesByEntityName, options) => {
+    const { name, port } = { ...defaultOptions, ...options };
+    const app = express();
+    app.use(express.static(join(import.meta.dirname, "../../public")));
+    app.use("/js/node_modules", express.static(join(import.meta.dirname, "../../node_modules")));
+    app.use("/js/client", express.static(join(import.meta.dirname, "../../lib/client")));
+    app.use("/js/shared", express.static(join(import.meta.dirname, "../../lib/shared")));
+    app.use(express.json());
+    const declarations = modelContainer.schema.declarations;
+    const entities = declarations.filter(isEntityDecl);
+    const entitiesByName = Object.fromEntries(entities.map(entity => [entity.name, entity]));
+    const instancesByEntityNameInMemory = { ...instancesByEntityName };
+    app.get("/api/declarations", (req, res) => {
+        let filteredEntities;
+        switch (req.query["kind"]) {
+            case "Entity":
+                filteredEntities = entities.filter(isEntityDecl);
+                break;
+            case "TypeAlias":
+                filteredEntities = entities.filter(isTypeAliasDecl);
+                break;
+            case "Enum":
+                filteredEntities = entities.filter(isEnumDecl);
+                break;
+            default:
+                filteredEntities = declarations;
+        }
+        const body = {
+            declarations: filteredEntities.map(decl => ({
+                declaration: serializeDecl(decl),
+                instanceCount: instancesByEntityNameInMemory[decl.name]?.length ?? 0,
+            })),
+            localeEntity: modelContainer.schema.localeEntity?.name,
+        };
+        res.json(body);
+    });
+    app.get("/api/declarations/:name", (req, res) => {
+        const decl = declarations.find(decl => decl.name === req.params.name);
+        if (decl === undefined) {
+            res.status(404).send(`Declaration "${req.params.name}" not found`);
+            return;
+        }
+        const body = {
+            declaration: serializeDecl(decl),
+            instanceCount: instancesByEntityNameInMemory[decl.name]?.length ?? 0,
+            isLocaleEntity: decl === modelContainer.schema.localeEntity,
+        };
+        res.json(body);
+    });
+    app.get("/api/declarations/:name/instances", (req, res) => {
+        const decl = declarations.find(decl => decl.name === req.params.name);
+        if (decl === undefined) {
+            res.status(404).send(`Declaration "${req.params.name}" not found`);
+            return;
+        }
+        if (!isEntityDecl(decl)) {
+            res.status(400).send(`Declaration "${decl.name}" is not an entity`);
+            return;
+        }
+        const body = {
+            instances: instancesByEntityNameInMemory[req.params.name] ?? [],
+            isLocaleEntity: decl === modelContainer.schema.localeEntity,
+        };
+        res.json(body);
+    });
+    app.post("/api/declarations/:name/instances", async (req, res) => {
+        const decl = declarations.find(decl => decl.name === req.params.name);
+        if (decl === undefined) {
+            res.status(404).send(`Declaration "${req.params.name}" not found`);
+            return;
+        }
+        if (!isEntityDecl(decl)) {
+            res.status(400).send(`Declaration "${decl.name}" is not an entity`);
+            return;
+        }
+        const result = await createInstance(modelContainer, entitiesByName, instancesByEntityNameInMemory, decl.name, req.body, req.query["id"]);
+        if (isOk(result)) {
+            const body = {
+                instance: result.value,
+                isLocaleEntity: decl === modelContainer.schema.localeEntity,
+            };
+            res.json(body);
+        }
+        else {
+            res.status(result.error[0]).send(result.error[1]);
+        }
+    });
+    app.get("/api/declarations/:name/instances/:id", (req, res) => {
+        const decl = declarations.find(decl => decl.name === req.params.name);
+        if (decl === undefined) {
+            res.status(404).send(`Declaration "${req.params.name}" not found`);
+            return;
+        }
+        if (!isEntityDecl(decl)) {
+            res.status(400).send(`Declaration "${decl.name}" is not an entity`);
+            return;
+        }
+        const instance = instancesByEntityNameInMemory[decl.name]?.find(instance => instance.id === req.params.id);
+        if (instance === undefined) {
+            res.status(404).send(`Instance "${req.params.id}" not found`);
+            return;
+        }
+        const body = {
+            instance: instance,
+            isLocaleEntity: decl === modelContainer.schema.localeEntity,
+        };
+        res.json(body);
+    });
+    app.put("/api/declarations/:name/instances/:id", async (req, res) => {
+        const decl = declarations.find(decl => decl.name === req.params.name);
+        if (decl === undefined) {
+            res.status(404).send(`Declaration "${req.params.name}" not found`);
+            return;
+        }
+        if (!isEntityDecl(decl)) {
+            res.status(400).send(`Declaration "${decl.name}" is not an entity`);
+            return;
+        }
+        const result = await updateInstance(modelContainer, entitiesByName, instancesByEntityNameInMemory, decl.name, req.params.id, req.body);
+        if (isOk(result)) {
+            const body = {
+                instance: result.value,
+                isLocaleEntity: decl === modelContainer.schema.localeEntity,
+            };
+            res.json(body);
+        }
+        else {
+            res.status(result.error[0]).send(result.error[1]);
+        }
+    });
+    app.delete("/api/declarations/:name/instances/:id", async (req, res) => {
+        const decl = declarations.find(decl => decl.name === req.params.name);
+        if (decl === undefined) {
+            res.status(404).send(`Declaration "${req.params.name}" not found`);
+            return;
+        }
+        if (!isEntityDecl(decl)) {
+            res.status(400).send(`Declaration "${decl.name}" is not an entity`);
+            return;
+        }
+        const result = await deleteInstance(modelContainer, instancesByEntityNameInMemory, decl.name, req.params.id);
+        if (isOk(result)) {
+            const body = {
+                instance: result.value,
+                isLocaleEntity: decl === modelContainer.schema.localeEntity,
+            };
+            res.json(body);
+        }
+        else {
+            res.status(result.error[0]).send(result.error[1]);
+        }
+    });
+    app.get("/api/instances", (req, res) => {
+        const locales = (Array.isArray(req.query["locales"]) ? req.query["locales"] : [req.query["locales"]]).filter(locale => typeof locale === "string");
+        const body = {
+            instances: Object.fromEntries(Object.entries(instancesByEntityNameInMemory).map(([entityName, instances]) => [
+                entityName,
+                instances.map(instance => ({
+                    id: instance.id,
+                    name: getDisplayNameFromEntityInstance(serializeEntityDecl(entitiesByName[entityName]), instance.content, instance.id, locales),
+                })),
+            ])),
+        };
+        res.json(body);
+    });
+    app.get(/^\/.*/, (_req, res) => {
+        res.send(`<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>TSONDB</title>
+  <link rel="stylesheet" href="/css/styles.css">
+</head>
+<body>
+  <div id="app"></div>
+  <script type="importmap">
+    {
+      "imports": {
+        "preact": "/js/node_modules/preact/dist/preact.module.js",
+        "preact/hooks": "/js/node_modules/preact/hooks/dist/hooks.module.js",
+        "preact/jsx-runtime": "/js/node_modules/preact/jsx-runtime/dist/jsxRuntime.module.js",
+        "preact-iso": "/js/node_modules/preact-iso/src/index.js"
+      }
+    }
+  </script>
+  <script type="module" src="/js/client/index.js"></script>
+</body>
+</html>`);
+    });
+    app.listen(port, () => {
+        console.log(`${name} listening on http://localhost:${port}`);
+    });
+};

package/lib/server/instanceOperations.d.ts

@@ -0,0 +1,7 @@
+import { ModelContainer } from "../ModelContainer.js";
+import { EntityDecl } from "../schema/declarations/EntityDecl.js";
+import { InstanceContainer, InstancesByEntityName } from "../shared/utils/instances.js";
+import { Result } from "../utils/result.js";
+export declare const createInstance: (modelContainer: ModelContainer, entitiesByName: Record<string, EntityDecl>, instancesByEntityName: InstancesByEntityName, entityName: string, instance: unknown, idQueryParam: unknown) => Promise<Result<InstanceContainer, [code: number, message: string]>>;
+export declare const updateInstance: (modelContainer: ModelContainer, entitiesByName: Record<string, EntityDecl>, instancesByEntityName: InstancesByEntityName, entityName: string, id: string, instance: unknown) => Promise<Result<InstanceContainer, [code: number, message: string]>>;
+export declare const deleteInstance: (modelContainer: ModelContainer, instancesByEntityName: InstancesByEntityName, entityName: string, id: string) => Promise<Result<InstanceContainer, [code: number, message: string]>>;

package/lib/server/instanceOperations.js

@@ -0,0 +1,67 @@
+import { rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { v4 as uuidv4 } from "uuid";
+import { validateEntityDecl } from "../schema/declarations/EntityDecl.js";
+import { createValidators } from "../schema/Node.js";
+import { getErrorMessageForDisplay } from "../utils/error.js";
+import { error, ok } from "../utils/result.js";
+export const createInstance = async (modelContainer, entitiesByName, instancesByEntityName, entityName, instance, idQueryParam) => {
+    const entity = entitiesByName[entityName];
+    const validationErrors = validateEntityDecl(createValidators(instancesByEntityName), entity, instance);
+    if (validationErrors.length > 0) {
+        return error([400, validationErrors.map(getErrorMessageForDisplay).join("\n\n")]);
+    }
+    if (modelContainer.schema.localeEntity === entity && typeof idQueryParam !== "string") {
+        return error([400, "Missing id for locale entity"]);
+    }
+    const id = modelContainer.schema.localeEntity === entity ? idQueryParam : uuidv4();
+    if (modelContainer.schema.localeEntity === entity &&
+        instancesByEntityName[entity.name].some(instance => instance.id === id)) {
+        return error([400, `Duplicate id "${id}" for locale entity`]);
+    }
+    const fileName = `${id}.json`;
+    await writeFile(join(modelContainer.dataRootPath, entity.name, fileName), JSON.stringify(instance, undefined, 2), { encoding: "utf-8" });
+    const instanceContainer = {
+        fileName,
+        id,
+        content: instance,
+    };
+    instancesByEntityName[entity.name] = [
+        ...(instancesByEntityName[entity.name] ?? []),
+        instanceContainer,
+    ];
+    return ok(instanceContainer);
+};
+export const updateInstance = async (modelContainer, entitiesByName, instancesByEntityName, entityName, id, instance) => {
+    const instanceContainer = instancesByEntityName[entityName]?.find(instance => instance.id === id);
+    if (instanceContainer === undefined) {
+        return error([404, "Instance not found"]);
+    }
+    const entity = entitiesByName[entityName];
+    const validationErrors = validateEntityDecl(createValidators(instancesByEntityName), entity, instance);
+    if (validationErrors.length > 0) {
+        return error([400, validationErrors.map(getErrorMessageForDisplay).join("\n\n")]);
+    }
+    await writeFile(join(modelContainer.dataRootPath, entity.name, instanceContainer.fileName), JSON.stringify(instance, undefined, 2), { encoding: "utf-8" });
+    instanceContainer.content = instance;
+    return ok(instanceContainer);
+};
+export const deleteInstance = async (modelContainer, instancesByEntityName, entityName, id) => {
+    const instances = instancesByEntityName[entityName] ?? [];
+    const instanceContainerIndex = instances.findIndex(instance => instance.id === id);
+    const instanceContainer = instances[instanceContainerIndex];
+    if (instanceContainer === undefined) {
+        return error([404, "Instance not found"]);
+    }
+    try {
+        await rm(join(modelContainer.dataRootPath, entityName, instanceContainer.fileName));
+        instancesByEntityName[entityName] = [
+            ...instances.slice(0, instanceContainerIndex),
+            ...instances.slice(instanceContainerIndex + 1),
+        ];
+        return ok(instanceContainer);
+    }
+    catch (err) {
+        return error([500, `Failed to delete instance: ${err}`]);
+    }
+};

package/lib/shared/api.d.ts

@@ -0,0 +1,42 @@
+import { SerializedDecl } from "../schema/declarations/Declaration.js";
+import { InstanceContainer } from "./utils/instances.js";
+export interface GetAllDeclarationsResponseBody<D extends SerializedDecl = SerializedDecl> {
+    declarations: {
+        declaration: D;
+        instanceCount: number;
+    }[];
+    localeEntity?: string;
+}
+export interface GetDeclarationResponseBody<D extends SerializedDecl = SerializedDecl> {
+    declaration: D;
+    instanceCount: number;
+    isLocaleEntity: boolean;
+}
+export interface GetAllInstancesOfEntityResponseBody {
+    instances: InstanceContainer[];
+    isLocaleEntity: boolean;
+}
+export interface CreateInstanceOfEntityResponseBody {
+    instance: InstanceContainer;
+    isLocaleEntity: boolean;
+}
+export interface GetInstanceOfEntityResponseBody {
+    instance: InstanceContainer;
+    isLocaleEntity: boolean;
+}
+export interface UpdateInstanceOfEntityResponseBody {
+    instance: InstanceContainer;
+    isLocaleEntity: boolean;
+}
+export interface DeleteInstanceOfEntityResponseBody {
+    instance: InstanceContainer;
+    isLocaleEntity: boolean;
+}
+export interface GetAllInstancesResponseBody {
+    instances: {
+        [entity: string]: {
+            id: string;
+            name: string;
+        }[];
+    };
+}

package/lib/shared/api.js

@@ -0,0 +1 @@
+export {};

package/lib/shared/enum.d.ts

@@ -0,0 +1 @@
+export declare const discriminatorKey = "kind";

package/lib/shared/enum.js

@@ -0,0 +1 @@
+export const discriminatorKey = "kind";

package/lib/shared/utils/compare.d.ts

@@ -0,0 +1,13 @@
+export type ComparisonOperator = (a: number, b: number) => boolean;
+export declare const lt: ComparisonOperator;
+export declare const lte: ComparisonOperator;
+export declare const gt: ComparisonOperator;
+export declare const gte: ComparisonOperator;
+export declare const eq: ComparisonOperator;
+export declare const neq: ComparisonOperator;
+/**
+ * Checks two values for value equality. This is a deep equality check that
+ * works for all types, including objects and arrays. For objects, it only
+ * compares all enumerable keys, no other properties or the prototype chain.
+ */
+export declare const deepEqual: <T>(a: T, b: T) => boolean;

package/lib/shared/utils/compare.js

@@ -0,0 +1,24 @@
+export const lt = (a, b) => a < b;
+export const lte = (a, b) => a <= b;
+export const gt = (a, b) => a > b;
+export const gte = (a, b) => a >= b;
+export const eq = (a, b) => a === b;
+export const neq = (a, b) => a !== b;
+/**
+ * Checks two values for value equality. This is a deep equality check that
+ * works for all types, including objects and arrays. For objects, it only
+ * compares all enumerable keys, no other properties or the prototype chain.
+ */
+export const deepEqual = (a, b) => {
+    if (a === b) {
+        return true;
+    }
+    if (typeof a === "object" && typeof b === "object" && a !== null && b !== null) {
+        const keys = Object.keys(a);
+        if (keys.length !== Object.keys(b).length) {
+            return false;
+        }
+        return keys.every(key => key in b && deepEqual(a[key], b[key]));
+    }
+    return false;
+};

package/lib/shared/utils/displayName.d.ts

@@ -0,0 +1,2 @@
+import { SerializedEntityDecl } from "../../schema/index.js";
+export declare const getDisplayNameFromEntityInstance: (entity: SerializedEntityDecl, instance: unknown, defaultName: string, locales?: string[]) => string;

package/lib/shared/utils/displayName.js

@@ -0,0 +1,31 @@
+const getValueAtPath = (value, path) => {
+    const parts = path.split(".");
+    let current = value;
+    for (const part of parts) {
+        if (typeof current === "object" && current !== null && part in current) {
+            current = current[part];
+        }
+        else {
+            return undefined;
+        }
+    }
+    return current;
+};
+export const getDisplayNameFromEntityInstance = (entity, instance, defaultName, locales = []) => {
+    const displayNamePath = entity.displayName ?? "name";
+    if (typeof displayNamePath === "string") {
+        return getValueAtPath(instance, displayNamePath) ?? defaultName;
+    }
+    else {
+        const localeMapPath = displayNamePath.pathToLocaleMap ?? "translations";
+        const localeMap = getValueAtPath(instance, localeMapPath);
+        const pathInLocaleMap = displayNamePath.pathInLocaleMap ?? "name";
+        const availableLocales = Object.keys(localeMap ?? {});
+        return availableLocales.length === 0
+            ? defaultName
+            : locales.reduce((name, locale) => name ??
+                getValueAtPath(localeMap[locale], pathInLocaleMap), undefined) ??
+                getValueAtPath(localeMap[availableLocales[0]], pathInLocaleMap) ??
+                defaultName;
+    }
+};

package/lib/shared/utils/instances.d.ts

@@ -0,0 +1,6 @@
+export interface InstanceContainer {
+    fileName: string;
+    id: string;
+    content: unknown;
+}
+export type InstancesByEntityName = Record<string, InstanceContainer[]>;

package/lib/shared/utils/instances.js

@@ -0,0 +1 @@
+export {};

package/lib/shared/utils/object.d.ts

@@ -0,0 +1,2 @@
+export declare const sortObjectKeys: (obj: Record<string, unknown>, keys: string[]) => Record<string, unknown>;
+export declare const sortObjectKeysAlphabetically: (obj: Record<string, unknown>) => Record<string, unknown>;

package/lib/shared/utils/object.js

@@ -0,0 +1,2 @@
+export const sortObjectKeys = (obj, keys) => Object.fromEntries(keys.flatMap(key => (obj[key] === undefined ? [] : [[key, obj[key]]])));
+export const sortObjectKeysAlphabetically = (obj) => Object.fromEntries(Object.entries(obj).sort(([keyA], [keyB]) => keyA.localeCompare(keyB)));

package/lib/shared/utils/string.d.ts

@@ -0,0 +1,6 @@
+export declare const splitStringParts: (str: string) => string[];
+export declare const toPascalCase: (str: string) => string;
+export declare const toCamelCase: (str: string) => string;
+export declare const toKebabCase: (str: string) => string;
+export declare const toSnakeCase: (str: string) => string;
+export declare const toTitleCase: (str: string) => string;

package/lib/shared/utils/string.js

@@ -0,0 +1,52 @@
+const letterOrDigit = /[a-zA-Z0-9]/;
+const uppercase = /[A-Z]/;
+const lowerCaseOrDigit = /[a-z0-9]/;
+const separator = /[^a-z0-9]/;
+const lastChar = (str) => str[str.length - 1];
+const lastElement = (arr) => arr[arr.length - 1];
+const isAllUppercase = (str) => str === str.toUpperCase();
+export const splitStringParts = (str) => [...str].reduce((acc, char, i, strArr) => {
+    if (acc.length === 0) {
+        return letterOrDigit.test(char) ? [char] : acc;
+    }
+    const lastPart = lastElement(acc);
+    if (uppercase.test(char)) {
+        const lastCharOfLastPart = lastChar(lastPart);
+        const nextChar = strArr[i + 1];
+        if (lastCharOfLastPart === undefined ||
+            (uppercase.test(lastCharOfLastPart) && (nextChar === undefined || separator.test(nextChar)))) {
+            return [...acc.slice(0, -1), lastPart + char];
+        }
+        else {
+            return [...acc, char];
+        }
+    }
+    if (lowerCaseOrDigit.test(char)) {
+        return [...acc.slice(0, -1), lastPart + char];
+    }
+    if (lastPart === "") {
+        return acc;
+    }
+    else {
+        return [...acc, ""];
+    }
+}, []);
+export const toPascalCase = (str) => splitStringParts(isAllUppercase(str) ? str.toLowerCase() : str)
+    .map(part => isAllUppercase(part) ? part : part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())
+    .join("");
+export const toCamelCase = (str) => splitStringParts(isAllUppercase(str) ? str.toLowerCase() : str)
+    .map((part, i) => i === 0
+    ? part.toLowerCase()
+    : isAllUppercase(part)
+        ? part
+        : part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())
+    .join("");
+export const toKebabCase = (str) => splitStringParts(str)
+    .map(part => part.toLowerCase())
+    .join("-");
+export const toSnakeCase = (str) => splitStringParts(str)
+    .map(part => part.toLowerCase())
+    .join("_");
+export const toTitleCase = (str) => splitStringParts(str)
+    .map(part => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())
+    .join(" ");

package/lib/shared/utils/typeSafety.d.ts

@@ -0,0 +1 @@
+export declare const assertExhaustive: (_x: never, msg?: string) => never;

package/lib/shared/utils/typeSafety.js

@@ -0,0 +1,3 @@
+export const assertExhaustive = (_x, msg = "The switch is not exhaustive.") => {
+    throw new Error(msg);
+};

package/lib/shared/utils/validation.d.ts

@@ -0,0 +1,3 @@
+export declare const parallelizeErrors: (errors: (Error | undefined)[]) => Error[];
+export type NumerusLabel = [singular: string, plural: string];
+export declare const validateLengthRangeBound: (end: "lower" | "upper", label: string | NumerusLabel, rangeBound: number | undefined, value: unknown[]) => Error | undefined;

package/lib/shared/utils/validation.js

@@ -0,0 +1,14 @@
+import { gte, lte } from "./compare.js";
+export const parallelizeErrors = (errors) => errors.filter(error => error !== undefined);
+export const validateLengthRangeBound = (end, label, rangeBound, value) => {
+    if (rangeBound === undefined) {
+        return;
+    }
+    const [operator, description] = end === "lower" ? [gte, "least"] : [lte, "most"];
+    const length = value.length;
+    const normalizedLabel = Array.isArray(label) ? label : [label, label + "s"];
+    if (!operator(length, rangeBound)) {
+        return RangeError(`Expected at ${description} ${rangeBound} ${normalizedLabel[rangeBound === 1 ? 0 : 1]}, but got ${length} ${normalizedLabel[length === 1 ? 0 : 1]}`);
+    }
+    return;
+};

package/lib/shared/validation/array.d.ts

@@ -0,0 +1,6 @@
+export interface ArrayConstraints {
+    minItems?: number;
+    maxItems?: number;
+    uniqueItems?: boolean;
+}
+export declare const validateArrayConstraints: (constraints: ArrayConstraints, value: unknown[]) => Error[];

package/lib/shared/validation/array.js

@@ -0,0 +1,29 @@
+import { parallelizeErrors, validateLengthRangeBound } from "../utils/validation.js";
+export const validateArrayConstraints = (constraints, value) => parallelizeErrors([
+    validateLengthRangeBound("lower", "item", constraints.minItems, value),
+    validateLengthRangeBound("upper", "item", constraints.maxItems, value),
+    constraints.uniqueItems
+        ? (() => {
+            // if (typeof this.uniqueItems === "function") {
+            //   const seen = new Set<any>()
+            //   for (const item of value) {
+            //     for (const other of seen) {
+            //       if (this.uniqueItems(item, other)) {
+            //         return TypeError(`Duplicate item found: ${JSON.stringify(item)}`)
+            //       }
+            //     }
+            //     seen.add(item)
+            //   }
+            // } else {
+            const seen = new Set();
+            for (const item of value) {
+                if (seen.has(item)) {
+                    return TypeError(`duplicate item found: ${JSON.stringify(item)}`);
+                }
+                seen.add(item);
+            }
+            return undefined;
+            // }
+        })()
+        : undefined,
+]);

package/lib/shared/validation/date.d.ts

@@ -0,0 +1,4 @@
+export interface DateConstraints {
+    time?: boolean;
+}
+export declare const validateDateConstraints: (constraints: DateConstraints, value: string) => Error[];

package/lib/shared/validation/date.js

@@ -0,0 +1,13 @@
+import { parallelizeErrors } from "../utils/validation.js";
+const datePattern = /^\d{4}-\d{2}-\d{2}$/;
+const dateTimePattern = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/;
+const isValidISODateString = (dateString) => !isNaN(new Date(dateString).getTime());
+export const validateDateConstraints = (constraints, value) => parallelizeErrors([
+    constraints.time === true
+        ? dateTimePattern.test(value) && isValidISODateString(value)
+            ? undefined
+            : TypeError(`invalid ISO 8601 date time string: ${value}`)
+        : datePattern.test(value) && isValidISODateString(value)
+            ? undefined
+            : TypeError(`invalid ISO 8601 date-only string: ${value}`),
+]);

package/lib/shared/validation/identifier.d.ts

@@ -0,0 +1 @@
+export declare const validateLocaleIdentifier: (value: string) => Error[];

package/lib/shared/validation/identifier.js

@@ -0,0 +1,7 @@
+export const validateLocaleIdentifier = (value) => {
+    const localePattern = /^[a-z]{2,3}(-[A-Z]{2,3})?$/;
+    if (localePattern.test(value)) {
+        return [];
+    }
+    return [TypeError(`invalid locale identifier: ${JSON.stringify(value)}`)];
+};

package/lib/shared/validation/number.d.ts

@@ -0,0 +1,12 @@
+export interface NumberConstraints {
+    minimum?: RangeBound;
+    maximum?: RangeBound;
+    multipleOf?: number;
+}
+export declare const validateNumberConstraints: (constraints: NumberConstraints, value: number) => Error[];
+export type RangeBound = number | {
+    value: number;
+    isExclusive: boolean;
+};
+export declare const validateRangeBound: (end: "lower" | "upper", rangeBound: RangeBound | undefined, value: number) => Error | undefined;
+export declare const validateMultipleOf: (multipleOf: number | undefined, value: number) => Error | undefined;

package/lib/shared/validation/number.js

@@ -0,0 +1,34 @@
+import { gt, gte, lt, lte } from "../utils/compare.js";
+import { parallelizeErrors } from "../utils/validation.js";
+export const validateNumberConstraints = (constraints, value) => parallelizeErrors([
+    validateRangeBound("lower", constraints.minimum, value),
+    validateRangeBound("upper", constraints.maximum, value),
+    validateMultipleOf(constraints.multipleOf, value),
+]);
+const normalizeRangeBound = (rangeBound) => typeof rangeBound === "number" ? { value: rangeBound, isExclusive: false } : rangeBound;
+export const validateRangeBound = (end, rangeBound, value) => {
+    if (rangeBound === undefined) {
+        return;
+    }
+    const normalizedRangeBound = normalizeRangeBound(rangeBound);
+    const [operator, description] = end === "lower"
+        ? normalizedRangeBound.isExclusive
+            ? [gt, "greater than"]
+            : [gte, "greater than or equal"]
+        : normalizedRangeBound.isExclusive
+            ? [lt, "less than"]
+            : [lte, "less than or equal"];
+    if (operator(value, normalizedRangeBound.value)) {
+        return RangeError(`expected a value ${description} ${normalizedRangeBound.value}, but got ${value}`);
+    }
+    return;
+};
+export const validateMultipleOf = (multipleOf, value) => {
+    if (multipleOf === undefined) {
+        return;
+    }
+    if (value % multipleOf !== 0) {
+        return RangeError(`expected a value that is a multiple of ${multipleOf}, but got ${value}`);
+    }
+    return;
+};