@cms0/shared 0.1.0 → 0.2.14

package/dist/esm/descriptor-capabilities.js

@@ -0,0 +1,385 @@
+import { createTaggedUnionValue, getUnionBranchKeyAt, getUnionBranchKeys, isTaggedUnionValue, } from "./union.js";
+function isPlainRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+export function isPrimitiveDescriptor(descriptor) {
+    if (!descriptor)
+        return false;
+    const type = descriptor.type;
+    return (descriptor.kind === "primitive" ||
+        (!descriptor.kind && type !== "object" && type !== "array"));
+}
+export function isEnumDescriptor(descriptor) {
+    return descriptor?.kind === "enum";
+}
+export function isUnionDescriptor(descriptor) {
+    return descriptor?.kind === "union";
+}
+export function isModelRefDescriptor(descriptor) {
+    return descriptor?.kind === "modelRef";
+}
+export function isObjectDescriptor(descriptor) {
+    return !!descriptor && descriptor.type === "object";
+}
+export function isArrayDescriptor(descriptor) {
+    return !!descriptor && descriptor.type === "array";
+}
+export function getModelDescriptor(fullDescriptor, modelName) {
+    if (!fullDescriptor || !modelName)
+        return undefined;
+    return fullDescriptor.models?.[modelName];
+}
+export function getDescriptorPropertyEntries(descriptor) {
+    const properties = descriptor.properties ?? {};
+    const order = Array.isArray(descriptor.propertyOrder)
+        ? descriptor.propertyOrder
+        : [];
+    const ordered = order
+        .filter((key) => Object.prototype.hasOwnProperty.call(properties, key))
+        .map((key) => [key, properties[key]]);
+    const remaining = Object.entries(properties)
+        .filter(([key]) => !order.includes(key))
+        .sort(([left], [right]) => left.localeCompare(right));
+    return [...ordered, ...remaining];
+}
+export function resolveAssetKindFromModelDescriptor(modelName, modelDescriptor) {
+    const presentation = modelDescriptor?.presentation;
+    if (presentation?.kind === "asset") {
+        if (presentation.assetKind === "image")
+            return "image";
+        if (presentation.assetKind === "video")
+            return "video";
+        return "file";
+    }
+    if (modelName === "Image")
+        return "image";
+    if (modelName === "Video")
+        return "video";
+    if (modelName === "File")
+        return "file";
+    return null;
+}
+export function resolveDescriptorCapability(descriptor, fullDescriptor) {
+    if (isUnionDescriptor(descriptor)) {
+        const keys = getUnionBranchKeys(descriptor);
+        const branches = Array.isArray(descriptor.anyOf) ? descriptor.anyOf : [];
+        return {
+            kind: "union",
+            discriminatorKey: descriptor.discriminator?.key,
+            branches: branches.map((branch, index) => ({
+                index,
+                key: keys[index] ?? getUnionBranchKeyAt(descriptor, index) ?? `branch_${index + 1}`,
+                descriptor: branch,
+                capability: resolveDescriptorCapability(branch, fullDescriptor),
+                label: getDescriptorDisplayName(branch, index),
+            })),
+        };
+    }
+    if (isModelRefDescriptor(descriptor)) {
+        const modelDescriptor = getModelDescriptor(fullDescriptor, descriptor.model);
+        const assetKind = resolveAssetKindFromModelDescriptor(descriptor.model, modelDescriptor);
+        if (assetKind) {
+            return {
+                kind: "asset-ref",
+                modelName: descriptor.model,
+                assetKind,
+                modelDescriptor,
+            };
+        }
+        return {
+            kind: "model-ref",
+            modelName: descriptor.model,
+            modelDescriptor,
+        };
+    }
+    if (isEnumDescriptor(descriptor)) {
+        return {
+            kind: "enum",
+            valueType: descriptor.valueType,
+            options: Array.isArray(descriptor.values) ? descriptor.values.slice() : [],
+        };
+    }
+    if (isObjectDescriptor(descriptor)) {
+        return {
+            kind: "object-inline",
+            properties: getDescriptorPropertyEntries(descriptor),
+        };
+    }
+    if (isArrayDescriptor(descriptor)) {
+        return {
+            kind: "collection-inline",
+            itemDescriptor: descriptor.items,
+        };
+    }
+    if (!isPrimitiveDescriptor(descriptor)) {
+        return {
+            kind: "unsupported",
+            reason: "Unsupported descriptor kind.",
+        };
+    }
+    if (descriptor.customType === "LocalizedString") {
+        return { kind: "localized-string" };
+    }
+    if (descriptor.customType === "RichText") {
+        return { kind: "rich-text" };
+    }
+    if (descriptor.customType === "LocalizedRichText") {
+        return { kind: "localized-rich-text" };
+    }
+    return {
+        kind: "scalar",
+        primitiveType: descriptor.type,
+        customType: descriptor.customType,
+    };
+}
+export function getDescriptorDefaultValue(descriptor, options = {}) {
+    const capability = resolveDescriptorCapability(descriptor);
+    if (capability.kind === "localized-string") {
+        const locales = options.locales?.length ? [...options.locales] : [options.defaultLocale ?? "en"];
+        const defaultLocale = options.defaultLocale ?? locales[0] ?? "en";
+        return {
+            defaultLocale,
+            locales: Object.fromEntries(locales.map((locale) => [locale, ""])),
+        };
+    }
+    if (capability.kind === "rich-text") {
+        return { value: {}, html: "" };
+    }
+    if (capability.kind === "localized-rich-text") {
+        const locales = options.locales?.length ? [...options.locales] : [options.defaultLocale ?? "en"];
+        const defaultLocale = options.defaultLocale ?? locales[0] ?? "en";
+        return {
+            defaultLocale,
+            locales: Object.fromEntries(locales.map((locale) => [locale, { value: {}, html: "" }])),
+        };
+    }
+    if (capability.kind === "model-ref" || capability.kind === "asset-ref") {
+        return null;
+    }
+    if (capability.kind === "enum") {
+        return capability.options[0] ?? null;
+    }
+    if (capability.kind === "union") {
+        const firstBranch = capability.branches[0];
+        if (!firstBranch)
+            return null;
+        return createTaggedUnionValue(descriptor, 0, getDescriptorDefaultValue(firstBranch.descriptor, options));
+    }
+    if (capability.kind === "object-inline") {
+        return Object.fromEntries(capability.properties.map(([key, propertyDescriptor]) => [
+            key,
+            getDescriptorDefaultValue(propertyDescriptor, options),
+        ]));
+    }
+    if (capability.kind === "collection-inline") {
+        return [];
+    }
+    if (capability.kind === "scalar") {
+        if (capability.primitiveType === "string")
+            return "";
+        if (capability.primitiveType === "number")
+            return 0;
+        if (capability.primitiveType === "boolean")
+            return false;
+        return null;
+    }
+    return null;
+}
+export function normalizeEnumValue(descriptor, value) {
+    const valueType = (descriptor.valueType ?? "string");
+    const values = Array.isArray(descriptor.values) ? descriptor.values : [];
+    let normalized = value;
+    if (valueType === "string") {
+        normalized = value == null ? "" : String(value);
+    }
+    else if (valueType === "number") {
+        if (typeof value === "number" && Number.isFinite(value)) {
+            normalized = value;
+        }
+        else {
+            const parsed = Number(value);
+            normalized = Number.isFinite(parsed) ? parsed : null;
+        }
+    }
+    else if (valueType === "boolean") {
+        if (value === true || value === "true" || value === 1 || value === "1") {
+            normalized = true;
+        }
+        else if (value === false || value === "false" || value === 0 || value === "0") {
+            normalized = false;
+        }
+        else {
+            normalized = Boolean(value);
+        }
+    }
+    if (!values.length)
+        return normalized;
+    if (values.some((entry) => Object.is(entry, normalized))) {
+        return normalized;
+    }
+    return values[0];
+}
+export function formatEnumOptionValue(value) {
+    return JSON.stringify(value);
+}
+export function parseEnumOptionValue(raw, valueType) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (valueType === "string")
+            return String(parsed ?? "");
+        if (valueType === "number") {
+            const num = Number(parsed);
+            return Number.isFinite(num) ? num : null;
+        }
+        return Boolean(parsed);
+    }
+    catch {
+        if (valueType === "number") {
+            const num = Number(raw);
+            return Number.isFinite(num) ? num : null;
+        }
+        if (valueType === "boolean") {
+            return raw === "true";
+        }
+        return raw;
+    }
+}
+function isUrlLikeString(input) {
+    return (typeof input === "string" &&
+        (input.includes("://") || input.startsWith("/") || input.startsWith("./")));
+}
+function isUuidLikeId(input) {
+    return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(input);
+}
+function normalizeModelRefValue(value) {
+    if (typeof value === "string" || typeof value === "number")
+        return value;
+    if (!isPlainRecord(value))
+        return null;
+    const id = value.id;
+    return typeof id === "string" || typeof id === "number" ? id : null;
+}
+function descriptorMatchScore(descriptor, value) {
+    if (isPrimitiveDescriptor(descriptor)) {
+        if (descriptor.type === "json")
+            return 1;
+        if (descriptor.type === "string")
+            return typeof value === "string" ? 4 : 0;
+        if (descriptor.type === "number")
+            return typeof value === "number" ? 4 : 0;
+        if (descriptor.type === "boolean")
+            return typeof value === "boolean" ? 4 : 0;
+        return 0;
+    }
+    if (isEnumDescriptor(descriptor)) {
+        const values = Array.isArray(descriptor.values) ? descriptor.values : [];
+        if (!values.length)
+            return 2;
+        return values.some((entry) => Object.is(entry, value)) ? 6 : 0;
+    }
+    if (isModelRefDescriptor(descriptor)) {
+        if (typeof value === "string") {
+            const normalized = value.trim();
+            if (!normalized)
+                return 0;
+            if (isUrlLikeString(normalized))
+                return 1;
+            return isUuidLikeId(normalized) ? 6 : 2;
+        }
+        if (typeof value === "number") {
+            return Number.isFinite(value) && value !== 0 ? 4 : 0;
+        }
+        const candidate = normalizeModelRefValue(value);
+        if (candidate == null)
+            return 0;
+        return typeof candidate === "string" && isUuidLikeId(candidate) ? 5 : 2;
+    }
+    if (isArrayDescriptor(descriptor)) {
+        return Array.isArray(value) ? 3 : 0;
+    }
+    if (isObjectDescriptor(descriptor)) {
+        if (!isPlainRecord(value))
+            return 0;
+        const keys = Object.keys(descriptor.properties ?? {});
+        const matched = keys.filter((key) => Object.prototype.hasOwnProperty.call(value, key)).length;
+        return 2 + matched;
+    }
+    if (isUnionDescriptor(descriptor)) {
+        const branches = Array.isArray(descriptor.anyOf) ? descriptor.anyOf : [];
+        if (!branches.length)
+            return 0;
+        return Math.max(...branches.map((branch) => descriptorMatchScore(branch, value)));
+    }
+    return 0;
+}
+export function resolveUnionBranchIndex(descriptor, value) {
+    const branches = Array.isArray(descriptor.anyOf) ? descriptor.anyOf : [];
+    if (!branches.length)
+        return 0;
+    const discriminatorKey = descriptor.discriminator?.key;
+    if (discriminatorKey && isPlainRecord(value)) {
+        const discriminatorValue = value[discriminatorKey];
+        for (let index = 0; index < branches.length; index += 1) {
+            const branch = branches[index];
+            const expected = branch?.properties?.[discriminatorKey]?.values?.[0];
+            if (expected !== undefined && Object.is(expected, discriminatorValue)) {
+                return index;
+            }
+        }
+    }
+    let bestIndex = 0;
+    let bestScore = -1;
+    for (let index = 0; index < branches.length; index += 1) {
+        const score = descriptorMatchScore(branches[index], value);
+        if (score > bestScore) {
+            bestScore = score;
+            bestIndex = index;
+        }
+    }
+    return bestIndex;
+}
+export function normalizeUnionValue(descriptor, value, options = {}) {
+    if (value == null) {
+        return null;
+    }
+    if (isTaggedUnionValue(value)) {
+        return value;
+    }
+    const branches = Array.isArray(descriptor.anyOf) ? descriptor.anyOf : [];
+    if (!branches.length)
+        return null;
+    const branchIndex = resolveUnionBranchIndex(descriptor, value);
+    const branchKey = getUnionBranchKeyAt(descriptor, branchIndex);
+    if (!branchKey)
+        return null;
+    const branchDescriptor = branches[branchIndex];
+    const branchValue = value == null
+        ? getDescriptorDefaultValue(branchDescriptor, options)
+        : value;
+    return createTaggedUnionValue(descriptor, branchIndex, branchValue);
+}
+export function getDescriptorDisplayName(descriptor, index = 0) {
+    const customType = descriptor?.customType;
+    if (typeof customType === "string" && customType.length > 0) {
+        return humanizeVisualText(customType);
+    }
+    if (isModelRefDescriptor(descriptor)) {
+        return humanizeVisualText(descriptor.model || `Branch ${index + 1}`);
+    }
+    if (isEnumDescriptor(descriptor))
+        return "Enum";
+    if (isUnionDescriptor(descriptor))
+        return "Union";
+    const descriptorType = descriptor?.type;
+    if (typeof descriptorType === "string") {
+        return humanizeVisualText(descriptorType);
+    }
+    return `Branch ${index + 1}`;
+}
+function humanizeVisualText(value) {
+    return value
+        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+        .replace(/[-_]+/g, " ")
+        .trim()
+        .replace(/\b\w/g, (match) => match.toUpperCase());
+}

package/dist/esm/index.js

@@ -1,2 +1,4 @@
 export * from "./validation.js";
+export * from "./union.js";
+export * from "./descriptor-capabilities.js";
 export const delay = (ms) => new Promise((res) => setTimeout(res, ms));

package/dist/esm/union.js

@@ -0,0 +1,159 @@
+export const CMS0_UNION_META_KEY = "__cms0Union";
+function isObjectRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeBranchShape(descriptor) {
+    if (descriptor?.kind === "modelRef") {
+        return {
+            kind: "modelRef",
+            model: descriptor.model,
+        };
+    }
+    if (descriptor?.kind === "enum") {
+        return {
+            kind: "enum",
+            valueType: descriptor.valueType ?? "string",
+            values: Array.isArray(descriptor.values)
+                ? [...descriptor.values]
+                : [],
+        };
+    }
+    if (descriptor?.kind === "union") {
+        const branches = Array.isArray(descriptor?.anyOf)
+            ? descriptor.anyOf
+            : [];
+        return {
+            kind: "union",
+            anyOf: branches.map((branch) => normalizeBranchShape(branch)),
+            ...(typeof descriptor?.discriminator?.key === "string"
+                ? { discriminator: { key: descriptor.discriminator.key } }
+                : {}),
+        };
+    }
+    if (descriptor?.type === "array") {
+        return {
+            kind: "array",
+            items: normalizeBranchShape(descriptor.items),
+        };
+    }
+    if (descriptor?.type === "object") {
+        const properties = descriptor?.properties &&
+            typeof descriptor.properties === "object"
+            ? descriptor.properties
+            : {};
+        const normalizedProperties = Object.fromEntries(Object.keys(properties)
+            .sort((a, b) => a.localeCompare(b))
+            .map((key) => [key, normalizeBranchShape(properties[key])]));
+        return {
+            kind: "object",
+            properties: normalizedProperties,
+        };
+    }
+    return {
+        kind: "primitive",
+        type: descriptor?.type ?? "json",
+        ...(typeof descriptor?.customType === "string"
+            ? { customType: descriptor.customType }
+            : {}),
+    };
+}
+function stableStringify(value) {
+    if (value === null)
+        return "null";
+    if (typeof value === "string")
+        return JSON.stringify(value);
+    if (typeof value === "number" || typeof value === "boolean")
+        return String(value);
+    if (Array.isArray(value)) {
+        return `[${value.map((entry) => stableStringify(entry)).join(",")}]`;
+    }
+    if (!isObjectRecord(value))
+        return JSON.stringify(value);
+    const entries = Object.keys(value)
+        .sort((a, b) => a.localeCompare(b))
+        .map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`);
+    return `{${entries.join(",")}}`;
+}
+function fnv1a32(input) {
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < input.length; i += 1) {
+        hash ^= input.charCodeAt(i);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return (hash >>> 0).toString(16).padStart(8, "0");
+}
+export function computeUnionBranchKeys(branches) {
+    const used = new Set();
+    return branches.map((branch, index) => {
+        const signature = stableStringify(normalizeBranchShape(branch));
+        const base = `branch_${fnv1a32(signature)}`;
+        let key = base;
+        let suffix = 1;
+        while (used.has(key)) {
+            suffix += 1;
+            key = `${base}_${suffix}`;
+        }
+        used.add(key);
+        return key || `branch_${index + 1}`;
+    });
+}
+export function getUnionBranchKeys(descriptor) {
+    const branches = Array.isArray(descriptor?.anyOf)
+        ? descriptor.anyOf
+        : [];
+    if (!branches.length)
+        return [];
+    const explicit = Array.isArray(descriptor?.branchKeys)
+        ? descriptor.branchKeys
+        : [];
+    const normalizedExplicit = explicit
+        .map((entry) => (typeof entry === "string" ? entry.trim() : ""))
+        .filter((entry) => entry.length > 0);
+    if (normalizedExplicit.length === branches.length &&
+        new Set(normalizedExplicit).size === normalizedExplicit.length) {
+        return normalizedExplicit;
+    }
+    return computeUnionBranchKeys(branches);
+}
+export function getUnionBranchKeyAt(descriptor, index) {
+    const keys = getUnionBranchKeys(descriptor);
+    return keys[index];
+}
+export function isTaggedUnionValue(value) {
+    if (!isObjectRecord(value))
+        return false;
+    const meta = value[CMS0_UNION_META_KEY];
+    if (!isObjectRecord(meta))
+        return false;
+    if (typeof meta.branchKey !== "string" || !meta.branchKey.trim())
+        return false;
+    return Object.prototype.hasOwnProperty.call(value, "value");
+}
+export function encodeTaggedUnionValue(branchKey, value) {
+    return {
+        [CMS0_UNION_META_KEY]: { branchKey },
+        value,
+    };
+}
+export function decodeTaggedUnionValue(value) {
+    if (!isTaggedUnionValue(value))
+        return null;
+    const meta = value[CMS0_UNION_META_KEY];
+    return {
+        branchKey: meta.branchKey.trim(),
+        value: value.value,
+    };
+}
+export function createTaggedUnionValue(descriptor, branchIndex, branchValue) {
+    const branchKey = getUnionBranchKeyAt(descriptor, branchIndex);
+    if (!branchKey)
+        return null;
+    return encodeTaggedUnionValue(branchKey, branchValue);
+}
+export function resolveTaggedUnionBranchIndex(descriptor, value) {
+    const decoded = decodeTaggedUnionValue(value);
+    if (!decoded)
+        return -1;
+    const keys = getUnionBranchKeys(descriptor);
+    return keys.findIndex((key) => key === decoded.branchKey);
+}

package/dist/esm/validation.js

@@ -26,6 +26,66 @@ function convertDescriptorToZod(desc, modelZodSchemas, opts = {}) {
                 return applyOptionality(z.any());
         }
     }
+    if (desc.kind === "enum") {
+        const literals = Array.isArray(desc.values) ? desc.values : [];
+        if (!literals.length) {
+            switch (desc.valueType) {
+                case "number":
+                    return applyOptionality(z.number());
+                case "boolean":
+                    return applyOptionality(z.boolean());
+                case "string":
+                default:
+                    return applyOptionality(z.string());
+            }
+        }
+        if (desc.valueType === "string") {
+            const values = literals
+                .filter((value) => typeof value === "string")
+                .map((value) => value.trim())
+                .filter((value) => value.length > 0);
+            if (!values.length) {
+                return applyOptionality(z.string());
+            }
+            const unique = Array.from(new Set(values));
+            const [first, ...rest] = unique;
+            if (!first)
+                return applyOptionality(z.string());
+            return applyOptionality(z.enum([first, ...rest]));
+        }
+        if (desc.valueType === "number") {
+            const values = literals.filter((value) => typeof value === "number" && Number.isFinite(value));
+            if (!values.length)
+                return applyOptionality(z.number());
+            const unique = Array.from(new Set(values));
+            const [first, ...rest] = unique;
+            if (first === undefined)
+                return applyOptionality(z.number());
+            const schema = rest.length
+                ? z.union([z.literal(first), ...rest.map((value) => z.literal(value))])
+                : z.literal(first);
+            return applyOptionality(schema);
+        }
+        const values = literals.filter((value) => typeof value === "boolean");
+        if (!values.length)
+            return applyOptionality(z.boolean());
+        if (values.includes(true) && values.includes(false)) {
+            return applyOptionality(z.boolean());
+        }
+        return applyOptionality(z.literal(values[0]));
+    }
+    if (desc.kind === "union") {
+        const branches = (Array.isArray(desc.anyOf) ? desc.anyOf : [])
+            .map((branch) => convertDescriptorToZod(branch, modelZodSchemas, opts))
+            .filter(Boolean);
+        if (!branches.length)
+            return applyOptionality(z.any());
+        if (branches.length === 1)
+            return applyOptionality(branches[0]);
+        const [first, second, ...rest] = branches;
+        const schema = z.union([first, second, ...rest]);
+        return applyOptionality(schema);
+    }
     if (desc.kind === "modelRef") {
         const schema = modelZodSchemas[desc.model];
         const base = schema ?? z.any();