@cms0/cms0 0.2.7 → 0.2.9

package/dist/cjs/libs/cli/descriptor-builder-alt.cjs

@@ -8,6 +8,7 @@ exports.buildDescriptorAlt = buildDescriptorAlt;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const ts_morph_1 = require("ts-morph");
+const shared_1 = require("@cms0/shared");
 const config_loader_js_1 = require("./config-loader.cjs");
 const registry_js_1 = require("../../custom-types/registry.cjs");
 function resolveCustomTypeName(type) {
@@ -127,6 +128,39 @@ function descriptorFromType(type, modelNames, warnings, ctx, opts) {
     const { base, optional, nullable } = unwrapOptional(type);
     const isOptional = !!opts?.optional || optional;
     const isNullable = !!opts?.nullable || nullable;
+    if (base.isUnion()) {
+        const unionDescriptor = descriptorFromUnionType(base, modelNames, warnings, ctx);
+        if (unionDescriptor) {
+            return applyOptionalityToDescriptor(unionDescriptor, isOptional, isNullable);
+        }
+    }
+    if (base.isStringLiteral()) {
+        return {
+            kind: "enum",
+            valueType: "string",
+            values: [String(base.getLiteralValue())],
+            optional: isOptional,
+            nullable: isNullable,
+        };
+    }
+    if (base.isNumberLiteral()) {
+        return {
+            kind: "enum",
+            valueType: "number",
+            values: [Number(base.getLiteralValue())],
+            optional: isOptional,
+            nullable: isNullable,
+        };
+    }
+    if (base.isBooleanLiteral()) {
+        return {
+            kind: "enum",
+            valueType: "boolean",
+            values: [base.getText() === "true"],
+            optional: isOptional,
+            nullable: isNullable,
+        };
+    }
     if (base.isString()) {
         return {
             kind: "primitive",
@@ -195,6 +229,203 @@ function descriptorFromType(type, modelNames, warnings, ctx, opts) {
         nullable: isNullable,
     };
 }
+function descriptorFromUnionType(unionType, modelNames, warnings, ctx) {
+    const unionTypes = unionType.getUnionTypes();
+    if (!unionTypes.length)
+        return undefined;
+    const hasBroadString = unionTypes.some((entry) => entry.isString());
+    const hasBroadNumber = unionTypes.some((entry) => entry.isNumber());
+    const hasBroadBoolean = unionTypes.some((entry) => entry.isBoolean());
+    const filtered = unionTypes.filter((entry) => {
+        if (entry.isStringLiteral() && hasBroadString)
+            return false;
+        if (entry.isNumberLiteral() && hasBroadNumber)
+            return false;
+        if (entry.isBooleanLiteral() && hasBroadBoolean)
+            return false;
+        return true;
+    });
+    if (!filtered.length) {
+        if (hasBroadString) {
+            return { kind: "primitive", type: "string" };
+        }
+        if (hasBroadNumber) {
+            return { kind: "primitive", type: "number" };
+        }
+        if (hasBroadBoolean) {
+            return { kind: "primitive", type: "boolean" };
+        }
+        return undefined;
+    }
+    const literalEnum = resolveLiteralUnionAsEnum(filtered);
+    if (literalEnum) {
+        return literalEnum;
+    }
+    const branches = filtered
+        .map((entry, index) => descriptorFromType(entry, modelNames, warnings, `${ctx}|${index}`, {
+        optional: false,
+        nullable: false,
+    }))
+        .map((entry) => stripOptionality(entry));
+    const deduped = dedupeDescriptors(branches);
+    if (!deduped.length)
+        return undefined;
+    if (deduped.length === 1)
+        return deduped[0];
+    const discriminator = inferUnionDiscriminator(deduped);
+    const branchKeys = (0, shared_1.computeUnionBranchKeys)(deduped);
+    return {
+        kind: "union",
+        anyOf: deduped,
+        branchKeys,
+        ...(discriminator ? { discriminator: { key: discriminator } } : {}),
+    };
+}
+function stripOptionality(descriptor) {
+    const clone = JSON.parse(JSON.stringify(descriptor));
+    delete clone.optional;
+    delete clone.nullable;
+    return clone;
+}
+function dedupeDescriptors(descriptors) {
+    const seen = new Set();
+    const deduped = [];
+    for (const descriptor of descriptors) {
+        const key = JSON.stringify(descriptor);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        deduped.push(descriptor);
+    }
+    return deduped;
+}
+function resolveLiteralUnionAsEnum(types) {
+    if (!types.length)
+        return undefined;
+    const literals = [];
+    let kind;
+    for (const entry of types) {
+        if (entry.isStringLiteral()) {
+            if (kind && kind !== "string")
+                return undefined;
+            kind = "string";
+            literals.push(String(entry.getLiteralValue()));
+            continue;
+        }
+        if (entry.isNumberLiteral()) {
+            if (kind && kind !== "number")
+                return undefined;
+            kind = "number";
+            literals.push(Number(entry.getLiteralValue()));
+            continue;
+        }
+        if (entry.isBooleanLiteral()) {
+            if (kind && kind !== "boolean")
+                return undefined;
+            kind = "boolean";
+            literals.push(entry.getText() === "true");
+            continue;
+        }
+        return undefined;
+    }
+    if (!kind)
+        return undefined;
+    const unique = Array.from(new Set(literals));
+    return {
+        kind: "enum",
+        valueType: kind,
+        values: unique,
+    };
+}
+function inferUnionDiscriminator(descriptors) {
+    if (!descriptors.length ||
+        descriptors.some((entry) => entry?.type !== "object")) {
+        return undefined;
+    }
+    const objects = descriptors;
+    const sharedKeys = Object.keys(objects[0]?.properties ?? {}).filter((key) => objects.every((obj) => Object.prototype.hasOwnProperty.call(obj.properties ?? {}, key)));
+    for (const key of sharedKeys) {
+        const enumLikeValues = objects.map((obj) => {
+            const prop = (obj.properties ?? {})[key];
+            if (!prop)
+                return undefined;
+            if (prop.kind !== "enum" || !Array.isArray(prop.values) || prop.values.length !== 1) {
+                return undefined;
+            }
+            return prop.values[0];
+        });
+        if (enumLikeValues.some((value) => value === undefined)) {
+            continue;
+        }
+        const unique = new Set(enumLikeValues);
+        if (unique.size === enumLikeValues.length) {
+            return key;
+        }
+    }
+    return undefined;
+}
+function normalizePropertyOrder(keys, explicitOrder) {
+    const normalizedExplicit = Array.isArray(explicitOrder)
+        ? explicitOrder
+            .filter((value) => typeof value === "string")
+            .map((value) => value.trim())
+            .filter(Boolean)
+        : [];
+    const dedupedExplicit = Array.from(new Set(normalizedExplicit)).filter((key) => keys.includes(key));
+    const remaining = keys.filter((key) => !dedupedExplicit.includes(key));
+    return [...dedupedExplicit, ...remaining];
+}
+function applyFieldPropertyOrder(descriptor) {
+    if (!descriptor || typeof descriptor !== "object")
+        return descriptor;
+    if (descriptor.type === "object") {
+        const properties = (descriptor.properties ?? {});
+        const keys = Object.keys(properties);
+        for (const key of keys) {
+            properties[key] = applyFieldPropertyOrder(properties[key]);
+        }
+        descriptor.propertyOrder = normalizePropertyOrder(keys, descriptor.propertyOrder);
+        return descriptor;
+    }
+    if (descriptor.type === "array" && descriptor.items) {
+        descriptor.items = applyFieldPropertyOrder(descriptor.items);
+        return descriptor;
+    }
+    if (descriptor.kind === "union" && Array.isArray(descriptor.anyOf)) {
+        descriptor.anyOf = descriptor.anyOf.map((branch) => applyFieldPropertyOrder(branch));
+        return descriptor;
+    }
+    return descriptor;
+}
+function applyDescriptorOrderingMetadata(descriptor) {
+    const rootsOrder = Object.keys(descriptor.roots ?? {});
+    const modelsOrder = Object.keys(descriptor.models ?? {});
+    for (const modelName of modelsOrder) {
+        const model = descriptor.models?.[modelName];
+        if (!model || typeof model !== "object")
+            continue;
+        const keys = Object.keys(model.properties ?? {});
+        for (const key of keys) {
+            model.properties[key] = applyFieldPropertyOrder(model.properties[key]);
+        }
+        model.propertyOrder = normalizePropertyOrder(keys, model.propertyOrder);
+    }
+    for (const rootName of rootsOrder) {
+        const rootDescriptor = descriptor.roots?.[rootName];
+        if (!rootDescriptor)
+            continue;
+        descriptor.roots[rootName] = applyFieldPropertyOrder(rootDescriptor);
+    }
+    descriptor.metadata = {
+        ...(descriptor.metadata ?? {}),
+        ordering: {
+            ...(descriptor.metadata?.ordering ?? {}),
+            roots: rootsOrder,
+            models: modelsOrder,
+        },
+    };
+    return descriptor;
+}
 function collectModels(sourceFiles, modelNames, modelMap, warnings) {
     const handleShape = (name, type, ctx) => {
         if (modelMap[name])
@@ -296,15 +527,15 @@ function buildDescriptorAlt(resolved) {
     const referencedModelNames = new Set();
     collectReferencedModelNames(rootType, referencedModelNames, new Set(), "root");
     const referencedCustomTypeNames = new Set(Array.from(referencedModelNames).filter((n) => registry_js_1.customTypeNames.has(n)));
-    const referencedCustomModelNames = new Set(Array.from(referencedCustomTypeNames).filter((n) => registry_js_1.customModelTypeNames.has(n)));
-    const resolvedCustomTypeNames = (0, registry_js_1.resolveCustomTypeDependencies)(referencedCustomModelNames);
+    const resolvedCustomTypeNames = (0, registry_js_1.resolveCustomTypeDependencies)(referencedCustomTypeNames);
+    const resolvedCustomModelNames = new Set(Array.from(resolvedCustomTypeNames).filter((n) => registry_js_1.customModelTypeNames.has(n)));
     const modelNames = new Set([
         ...Array.from(referencedModelNames).filter((n) => exportedModelNames.has(n)),
-        ...Array.from(resolvedCustomTypeNames),
+        ...Array.from(resolvedCustomModelNames),
     ]);
     const modelMap = {};
     collectModels(sourceFiles, modelNames, modelMap, warnings);
-    resolvedCustomTypeNames.forEach((name) => {
+    resolvedCustomModelNames.forEach((name) => {
         if (modelMap[name]) {
             return;
         }
@@ -341,7 +572,7 @@ function buildDescriptorAlt(resolved) {
         warnings.forEach((w) => console.warn(w));
     const locales = invocation.locales;
     const defaultLocale = invocation.defaultLocale;
-    return {
+    const descriptor = {
         models: modelMap,
         roots,
         metadata: locales || defaultLocale
@@ -351,4 +582,5 @@ function buildDescriptorAlt(resolved) {
             }
             : undefined,
     };
+    return applyDescriptorOrderingMetadata(descriptor);
 }

package/dist/cjs/seo.cjs

@@ -0,0 +1,226 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveLocalized = resolveLocalized;
+exports.toOpenGraph = toOpenGraph;
+exports.toTwitter = toTwitter;
+exports.toNextMetadata = toNextMetadata;
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeText(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function uniqueNonEmpty(values) {
+    const result = [];
+    for (const value of values) {
+        const trimmed = normalizeText(value);
+        if (!trimmed || result.includes(trimmed))
+            continue;
+        result.push(trimmed);
+    }
+    return result;
+}
+function isLocalizedLike(value) {
+    if (!isRecord(value))
+        return false;
+    return "locales" in value && isRecord(value.locales);
+}
+function localizedValueForLocale(locales, locale) {
+    const entry = locales[locale];
+    return normalizeText(entry);
+}
+function resolveLocalized(value, options = {}) {
+    if (value == null)
+        return undefined;
+    if (typeof value === "string") {
+        return normalizeText(value);
+    }
+    if (!isLocalizedLike(value)) {
+        return undefined;
+    }
+    const locales = value.locales;
+    const localeKeys = Object.keys(locales);
+    const preferredLocales = uniqueNonEmpty([
+        options.locale,
+        typeof value.defaultLocale === "string" ? value.defaultLocale : undefined,
+        options.defaultLocale,
+        options.fallbackLocale,
+        ...localeKeys,
+    ]);
+    for (const locale of preferredLocales) {
+        const resolved = localizedValueForLocale(locales, locale);
+        if (resolved)
+            return resolved;
+    }
+    return undefined;
+}
+function resolveKeywords(value, options) {
+    if (Array.isArray(value)) {
+        const list = value.map((entry) => normalizeText(entry)).filter(Boolean);
+        return list.length ? list : undefined;
+    }
+    const localized = resolveLocalized(value, options);
+    if (!localized)
+        return undefined;
+    const parts = localized
+        .split(/[;,]/g)
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0);
+    if (parts.length > 0) {
+        return parts;
+    }
+    return [localized];
+}
+function resolveImageUrl(image) {
+    if (typeof image === "string") {
+        return normalizeText(image);
+    }
+    if (!isRecord(image))
+        return undefined;
+    return normalizeText(image.url);
+}
+function normalizeRobots(robots) {
+    if (typeof robots === "boolean") {
+        return { index: robots, follow: robots };
+    }
+    if (!isRecord(robots))
+        return undefined;
+    const resolved = {};
+    if (typeof robots.index === "boolean")
+        resolved.index = robots.index;
+    if (typeof robots.follow === "boolean")
+        resolved.follow = robots.follow;
+    if (typeof robots.nocache === "boolean")
+        resolved.nocache = robots.nocache;
+    return Object.keys(resolved).length ? resolved : undefined;
+}
+function hasAnyKeys(value) {
+    return Object.keys(value).length > 0;
+}
+function toOpenGraph(value, options = {}) {
+    if (!isRecord(value))
+        return undefined;
+    const openGraph = {};
+    const type = normalizeText(value.type);
+    if (type)
+        openGraph.type = type;
+    const url = normalizeText(value.url);
+    if (url)
+        openGraph.url = url;
+    const siteName = normalizeText(value.siteName);
+    if (siteName)
+        openGraph.siteName = siteName;
+    const title = resolveLocalized(value.title, options);
+    if (title)
+        openGraph.title = title;
+    const description = resolveLocalized(value.description, options);
+    if (description)
+        openGraph.description = description;
+    if (Array.isArray(value.images)) {
+        const images = value.images
+            .map((image) => resolveImageUrl(image))
+            .filter((entry) => typeof entry === "string" && entry.length > 0);
+        if (images.length) {
+            openGraph.images = images;
+        }
+    }
+    const locale = normalizeText(value.locale);
+    if (locale)
+        openGraph.locale = locale;
+    if (Array.isArray(value.alternateLocale)) {
+        const alternateLocale = value.alternateLocale
+            .map((entry) => normalizeText(entry))
+            .filter((entry) => Boolean(entry));
+        if (alternateLocale.length) {
+            openGraph.alternateLocale = alternateLocale;
+        }
+    }
+    return hasAnyKeys(openGraph) ? openGraph : undefined;
+}
+function toTwitter(value, options = {}) {
+    if (!isRecord(value))
+        return undefined;
+    const twitter = {};
+    const card = normalizeText(value.card);
+    if (card)
+        twitter.card = card;
+    const site = normalizeText(value.site);
+    if (site)
+        twitter.site = site;
+    const creator = normalizeText(value.creator);
+    if (creator)
+        twitter.creator = creator;
+    const title = resolveLocalized(value.title, options);
+    if (title)
+        twitter.title = title;
+    const description = resolveLocalized(value.description, options);
+    if (description)
+        twitter.description = description;
+    if (Array.isArray(value.images)) {
+        const images = value.images
+            .map((image) => resolveImageUrl(image))
+            .filter((entry) => typeof entry === "string" && entry.length > 0);
+        if (images.length) {
+            twitter.images = images;
+        }
+    }
+    return hasAnyKeys(twitter) ? twitter : undefined;
+}
+function resolveAlternates(seo) {
+    const alternates = {};
+    const canonical = normalizeText(seo.alternates?.canonical) ?? normalizeText(seo.canonical);
+    if (canonical) {
+        alternates.canonical = canonical;
+    }
+    if (isRecord(seo.alternates?.languages)) {
+        const languages = {};
+        for (const [locale, rawValue] of Object.entries(seo.alternates.languages)) {
+            const normalizedLocale = normalizeText(locale);
+            const normalizedUrl = normalizeText(rawValue);
+            if (!normalizedLocale || !normalizedUrl)
+                continue;
+            languages[normalizedLocale] = normalizedUrl;
+        }
+        if (Object.keys(languages).length) {
+            alternates.languages = languages;
+        }
+    }
+    return hasAnyKeys(alternates) ? alternates : undefined;
+}
+/**
+ * Maps a CMS0 `Seo` object to a Next.js-compatible metadata shape.
+ *
+ * The return type is generic so consumers can pass Next's `Metadata` type:
+ * `toNextMetadata<Metadata>(seo, { locale })`.
+ */
+function toNextMetadata(seo, options = {}) {
+    if (!isRecord(seo)) {
+        return {};
+    }
+    const metadata = {};
+    const title = resolveLocalized(seo.title, options);
+    if (title)
+        metadata.title = title;
+    const description = resolveLocalized(seo.description, options);
+    if (description)
+        metadata.description = description;
+    const keywords = resolveKeywords(seo.keywords, options);
+    if (keywords?.length)
+        metadata.keywords = keywords;
+    const robots = normalizeRobots(seo.robots);
+    if (robots)
+        metadata.robots = robots;
+    const alternates = resolveAlternates(seo);
+    if (alternates)
+        metadata.alternates = alternates;
+    const openGraph = toOpenGraph(seo.openGraph, options);
+    if (openGraph)
+        metadata.openGraph = openGraph;
+    const twitter = toTwitter(seo.twitter, options);
+    if (twitter)
+        metadata.twitter = twitter;
+    return metadata;
+}