convex-cms 0.0.1

package/dist/component/localeFields.d.ts

@@ -0,0 +1,508 @@
+/**
+ * Locale-Specific Content Field Storage and Resolution
+ *
+ * This module provides the schema and storage structure for locale-specific
+ * content field values. It allows fields marked as `localized: true` in their
+ * field definition to store translations keyed by locale code within content entries.
+ *
+ * Storage Structure:
+ * - Non-localized fields: { title: "Hello World" }
+ * - Localized fields: { title: { "en-US": "Hello World", "es-ES": "Hola Mundo" } }
+ *
+ * @example
+ * ```typescript
+ * // Content entry data with localized fields
+ * const data = {
+ *   // Non-localized field (same value for all locales)
+ *   slug: "my-post",
+ *
+ *   // Localized field (translations keyed by locale)
+ *   title: {
+ *     "en-US": "My Blog Post",
+ *     "es-ES": "Mi Entrada de Blog",
+ *     "fr-FR": "Mon Article de Blog",
+ *   },
+ *
+ *   // Localized rich text field
+ *   content: {
+ *     "en-US": "<p>Welcome to my blog!</p>",
+ *     "es-ES": "<p>¡Bienvenido a mi blog!</p>",
+ *   },
+ * };
+ * ```
+ */
+import type { FieldDefinition } from "../client/types.js";
+/**
+ * Represents a localized field value - a mapping from locale codes to translated values.
+ *
+ * @example
+ * ```typescript
+ * const localizedTitle: LocalizedFieldValue<string> = {
+ *   "en-US": "Hello World",
+ *   "es-ES": "Hola Mundo",
+ *   "fr-FR": "Bonjour le Monde",
+ * };
+ * ```
+ */
+export type LocalizedFieldValue<T = unknown> = {
+    [localeCode: string]: T;
+};
+/**
+ * Represents either a plain field value or a localized field value.
+ * Used when working with field values that may or may not be localized.
+ */
+export type FieldValue<T = unknown> = T | LocalizedFieldValue<T>;
+/**
+ * Options for resolving localized field values.
+ */
+export interface LocaleResolutionOptions {
+    /**
+     * The primary locale to attempt to resolve first.
+     */
+    locale: string;
+    /**
+     * Fallback chain of locales to try if the primary locale is not found.
+     * Tried in order until a value is found.
+     *
+     * @example
+     * ```typescript
+     * // Try en-US first, then en, then the default locale
+     * fallbackChain: ["en", "en-US"]
+     * ```
+     */
+    fallbackChain?: string[];
+    /**
+     * The default locale to use as final fallback.
+     * If not specified, returns undefined when no locale matches.
+     *
+     * @default "en"
+     */
+    defaultLocale?: string;
+}
+/**
+ * Result of resolving a localized field value.
+ */
+export interface LocaleResolutionResult<T = unknown> {
+    /**
+     * The resolved value, or undefined if no matching locale was found.
+     */
+    value: T | undefined;
+    /**
+     * The locale code that was used to resolve the value.
+     * Undefined if no matching locale was found.
+     */
+    resolvedLocale: string | undefined;
+    /**
+     * Whether the value was resolved from the primary requested locale
+     * (as opposed to a fallback).
+     */
+    isExactMatch: boolean;
+}
+/**
+ * Checks if a value is a LocalizedFieldValue structure.
+ *
+ * A value is considered localized if:
+ * - It is a non-null object
+ * - It is not an array
+ * - At least one key contains a hyphen (BCP 47 locale codes like "en-US")
+ * - All keys match the BCP 47 pattern (language[-Script][-REGION])
+ *
+ * Note: For fields that should store localized content, use the `localized: true`
+ * property in the field definition. This function is a heuristic type guard.
+ *
+ * @param value - The value to check
+ * @returns true if the value appears to be a LocalizedFieldValue
+ *
+ * @example
+ * ```typescript
+ * isLocalizedFieldValue({ "en-US": "Hello" }); // true
+ * isLocalizedFieldValue({ "en-US": "Hello", "es-ES": "Hola" }); // true
+ * isLocalizedFieldValue("Hello"); // false
+ * isLocalizedFieldValue({ foo: "bar" }); // false (no hyphenated locale key)
+ * isLocalizedFieldValue({ en: "Hello" }); // false (no hyphen - ambiguous)
+ * ```
+ */
+export declare function isLocalizedFieldValue(value: unknown): value is LocalizedFieldValue;
+/**
+ * Checks if a field definition indicates the field should be localized.
+ *
+ * @param fieldDef - The field definition to check
+ * @returns true if the field is marked as localized
+ */
+export declare function isFieldLocalized(fieldDef: FieldDefinition): boolean;
+/**
+ * Gets a value from a potentially localized field.
+ *
+ * If the field value is a LocalizedFieldValue, resolves using the specified locale
+ * with fallback chain. If it's a plain value, returns it directly.
+ *
+ * @param value - The field value (may be localized or plain)
+ * @param options - Locale resolution options
+ * @returns The resolved value result
+ *
+ * @example
+ * ```typescript
+ * // With localized value
+ * const localizedTitle = { "en-US": "Hello", "es-ES": "Hola" };
+ * const result = getLocalizedValue(localizedTitle, { locale: "es-ES" });
+ * // result: { value: "Hola", resolvedLocale: "es-ES", isExactMatch: true }
+ *
+ * // With fallback
+ * const result2 = getLocalizedValue(localizedTitle, {
+ *   locale: "fr-FR",
+ *   fallbackChain: ["en-US"],
+ * });
+ * // result2: { value: "Hello", resolvedLocale: "en-US", isExactMatch: false }
+ *
+ * // With plain value (non-localized field)
+ * const result3 = getLocalizedValue("Plain text", { locale: "en-US" });
+ * // result3: { value: "Plain text", resolvedLocale: undefined, isExactMatch: true }
+ * ```
+ */
+export declare function getLocalizedValue<T>(value: FieldValue<T>, options: LocaleResolutionOptions): LocaleResolutionResult<T>;
+/**
+ * Sets a value for a specific locale in a localized field.
+ *
+ * If the existing value is not localized, it converts it to a localized structure
+ * with the new value for the specified locale.
+ *
+ * @param existingValue - The current field value (may be localized or plain)
+ * @param locale - The locale to set the value for
+ * @param newValue - The new value to set
+ * @param preserveExisting - If true and converting from plain to localized,
+ *                          preserves the existing value under the default locale
+ * @param defaultLocale - The locale to use for preserving existing plain values
+ * @returns The updated localized field value
+ *
+ * @example
+ * ```typescript
+ * // Set value for a locale
+ * const existing = { "en-US": "Hello" };
+ * const updated = setLocalizedValue(existing, "es-ES", "Hola");
+ * // updated: { "en-US": "Hello", "es-ES": "Hola" }
+ *
+ * // Convert plain to localized
+ * const plain = "Hello";
+ * const converted = setLocalizedValue(plain, "es-ES", "Hola", true, "en-US");
+ * // converted: { "en-US": "Hello", "es-ES": "Hola" }
+ * ```
+ */
+export declare function setLocalizedValue<T>(existingValue: FieldValue<T> | undefined, locale: string, newValue: T, preserveExisting?: boolean, defaultLocale?: string): LocalizedFieldValue<T>;
+/**
+ * Removes a specific locale from a localized field value.
+ *
+ * @param localizedValue - The localized field value
+ * @param locale - The locale to remove
+ * @returns The updated localized field value, or undefined if empty
+ *
+ * @example
+ * ```typescript
+ * const value = { "en-US": "Hello", "es-ES": "Hola" };
+ * const updated = removeLocale(value, "es-ES");
+ * // updated: { "en-US": "Hello" }
+ * ```
+ */
+export declare function removeLocale<T>(localizedValue: LocalizedFieldValue<T>, locale: string): LocalizedFieldValue<T> | undefined;
+/**
+ * Merges translations from one localized value into another.
+ *
+ * @param target - The base localized value
+ * @param source - The localized value to merge in (overwrites existing locales)
+ * @returns The merged localized field value
+ *
+ * @example
+ * ```typescript
+ * const target = { "en-US": "Hello", "es-ES": "Hola" };
+ * const source = { "es-ES": "Hola!", "fr-FR": "Bonjour" };
+ * const merged = mergeLocalizedValues(target, source);
+ * // merged: { "en-US": "Hello", "es-ES": "Hola!", "fr-FR": "Bonjour" }
+ * ```
+ */
+export declare function mergeLocalizedValues<T>(target: LocalizedFieldValue<T> | undefined, source: LocalizedFieldValue<T>): LocalizedFieldValue<T>;
+/**
+ * Gets all available locales from a localized field value.
+ *
+ * @param value - The field value (may be localized or plain)
+ * @returns Array of locale codes, or empty array if not localized
+ *
+ * @example
+ * ```typescript
+ * const value = { "en-US": "Hello", "es-ES": "Hola" };
+ * const locales = getAvailableLocales(value);
+ * // locales: ["en-US", "es-ES"]
+ *
+ * const plain = "Hello";
+ * const locales2 = getAvailableLocales(plain);
+ * // locales2: []
+ * ```
+ */
+export declare function getAvailableLocales(value: FieldValue): string[];
+/**
+ * Checks if a localized field has a translation for a specific locale.
+ *
+ * @param value - The field value (may be localized or plain)
+ * @param locale - The locale to check
+ * @returns true if the locale has a translation
+ */
+export declare function hasLocale(value: FieldValue, locale: string): boolean;
+/**
+ * Options for resolving all localized fields in content data.
+ */
+export interface ResolveContentDataOptions extends LocaleResolutionOptions {
+    /**
+     * Field definitions for the content type.
+     * Used to determine which fields are localized.
+     */
+    fields: FieldDefinition[];
+}
+/**
+ * Result of resolving all localized fields in content data.
+ */
+export interface ResolvedContentData {
+    /**
+     * The resolved data with all localized fields resolved to single values.
+     */
+    data: Record<string, unknown>;
+    /**
+     * Map of field names to their resolution results.
+     */
+    resolutions: Record<string, LocaleResolutionResult>;
+    /**
+     * Fields that were missing translations for the requested locale.
+     */
+    missingTranslations: string[];
+}
+/**
+ * Resolves all localized fields in content data to single values for a specific locale.
+ *
+ * This function takes raw content entry data (which may contain LocalizedFieldValue
+ * structures for localized fields) and resolves each field to a single value
+ * based on the requested locale and fallback chain.
+ *
+ * @param data - The raw content entry data
+ * @param options - Resolution options including fields and locale settings
+ * @returns The resolved content data with metadata about resolution
+ *
+ * @example
+ * ```typescript
+ * const rawData = {
+ *   slug: "my-post", // non-localized
+ *   title: { "en-US": "Hello", "es-ES": "Hola" }, // localized
+ *   content: { "en-US": "Content here" }, // localized, missing es-ES
+ * };
+ *
+ * const result = resolveContentData(rawData, {
+ *   locale: "es-ES",
+ *   fallbackChain: ["en-US"],
+ *   fields: [
+ *     { name: "slug", localized: false, ... },
+ *     { name: "title", localized: true, ... },
+ *     { name: "content", localized: true, ... },
+ *   ],
+ * });
+ *
+ * // result.data: { slug: "my-post", title: "Hola", content: "Content here" }
+ * // result.missingTranslations: ["content"]
+ * ```
+ */
+export declare function resolveContentData(data: Record<string, unknown>, options: ResolveContentDataOptions): ResolvedContentData;
+/**
+ * Sets values for multiple localized fields for a specific locale.
+ *
+ * This function takes a partial data object with values for a specific locale
+ * and merges them into the existing content data's localized field structures.
+ *
+ * @param existingData - The existing content entry data
+ * @param newValues - New values to set (field name -> value)
+ * @param locale - The locale to set values for
+ * @param fields - Field definitions to determine which fields are localized
+ * @param defaultLocale - Default locale for preserving existing values
+ * @returns Updated content data with localized values merged in
+ *
+ * @example
+ * ```typescript
+ * const existingData = {
+ *   slug: "my-post",
+ *   title: { "en-US": "Hello" },
+ * };
+ *
+ * const updated = setLocalizedContentData(
+ *   existingData,
+ *   { title: "Hola", slug: "mi-post" }, // slug will be overwritten, title merged
+ *   "es-ES",
+ *   fields
+ * );
+ *
+ * // updated: {
+ * //   slug: "mi-post", // non-localized, just replaced
+ * //   title: { "en-US": "Hello", "es-ES": "Hola" }, // localized, merged
+ * // }
+ * ```
+ */
+export declare function setLocalizedContentData(existingData: Record<string, unknown>, newValues: Record<string, unknown>, locale: string, fields: FieldDefinition[], defaultLocale?: string): Record<string, unknown>;
+/**
+ * Result of resolving locale content for an entry with metadata.
+ */
+export interface LocaleResolvedEntry<T = Record<string, unknown>> {
+    /**
+     * The resolved data with all localized fields resolved to single values.
+     */
+    data: T;
+    /**
+     * Metadata about the locale resolution process.
+     */
+    localeResolution: {
+        /**
+         * The locale that was requested.
+         */
+        requestedLocale: string;
+        /**
+         * The fallback chain that was used for resolution.
+         */
+        fallbackChain: string[];
+        /**
+         * The default locale used as final fallback.
+         */
+        defaultLocale: string;
+        /**
+         * Fields that were resolved from a fallback locale (missing in requested locale).
+         */
+        fieldsFromFallback: string[];
+        /**
+         * Map of field names to the locale they were resolved from.
+         * Only includes fields that were resolved from a fallback (not the requested locale).
+         */
+        fieldResolutions: Record<string, string>;
+    };
+}
+/**
+ * Options for resolving locale content for entries.
+ */
+export interface ResolveLocaleOptions {
+    /**
+     * The locale to resolve content in.
+     */
+    locale: string;
+    /**
+     * Fallback chain of locales to try if the primary locale is not found.
+     */
+    fallbackChain?: string[];
+    /**
+     * The default locale to use as final fallback.
+     * @default "en"
+     */
+    defaultLocale?: string;
+    /**
+     * Field definitions for the content type.
+     * Used to determine which fields are localized.
+     */
+    fields: FieldDefinition[];
+    /**
+     * Whether to include locale resolution metadata in the result.
+     * @default true
+     */
+    includeResolutionMetadata?: boolean;
+}
+/**
+ * Resolves all localized fields in a content entry to the requested locale with fallback support.
+ *
+ * This function takes raw content entry data (which may contain LocalizedFieldValue
+ * structures for localized fields) and resolves each field to a single value
+ * based on the requested locale and fallback chain. It merges localized and
+ * non-localized field values into a unified data structure.
+ *
+ * Resolution order for each localized field:
+ * 1. Try the requested locale
+ * 2. Try each locale in the fallback chain (in order)
+ * 3. Try the default locale
+ * 4. Return first available locale as last resort
+ * 5. Return undefined if no value exists
+ *
+ * @param entry - The content entry with potentially localized data
+ * @param options - Locale resolution options
+ * @returns The entry with resolved locale data and resolution metadata
+ *
+ * @example
+ * ```typescript
+ * const entry = {
+ *   _id: "abc123",
+ *   slug: "my-post",
+ *   data: {
+ *     slug: "my-post", // non-localized
+ *     title: { "en-US": "Hello", "es-ES": "Hola" }, // localized
+ *     content: { "en-US": "Content here" }, // localized, missing es-ES
+ *   },
+ * };
+ *
+ * const resolved = resolveLocaleContent(entry, {
+ *   locale: "es-ES",
+ *   fallbackChain: ["en-US"],
+ *   defaultLocale: "en-US",
+ *   fields: contentType.fields,
+ * });
+ *
+ * // resolved.data: { slug: "my-post", title: "Hola", content: "Content here" }
+ * // resolved.localeResolution.fieldsFromFallback: ["content"]
+ * // resolved.localeResolution.fieldResolutions: { content: "en-US" }
+ * ```
+ */
+export declare function resolveLocaleContent<T extends {
+    data: Record<string, unknown>;
+}>(entry: T, options: ResolveLocaleOptions): T & LocaleResolvedEntry<Record<string, unknown>>;
+/**
+ * Resolves locale content for an array of content entries.
+ *
+ * This is a convenience function for batch-resolving multiple entries.
+ * Useful when fetching lists of content entries that need locale resolution.
+ *
+ * @param entries - Array of content entries to resolve
+ * @param options - Locale resolution options (applied to all entries)
+ * @returns Array of entries with resolved locale data
+ *
+ * @example
+ * ```typescript
+ * const entries = await cms.contentEntries.list(ctx, {
+ *   contentTypeName: "blog_post",
+ *   status: "published",
+ *   paginationOpts: { numItems: 10 },
+ * });
+ *
+ * const resolvedEntries = resolveLocaleContentBatch(entries.page, {
+ *   locale: "es-ES",
+ *   fallbackChain: cms.getLocaleFallbackChain("es-ES"),
+ *   defaultLocale: cms.config.defaultLocale,
+ *   fields: blogPostContentType.fields,
+ * });
+ * ```
+ */
+export declare function resolveLocaleContentBatch<T extends {
+    data: Record<string, unknown>;
+}>(entries: T[], options: ResolveLocaleOptions): Array<T & LocaleResolvedEntry<Record<string, unknown>>>;
+/**
+ * Gets the translation completeness status for content data across locales.
+ *
+ * @param data - The content entry data
+ * @param fields - Field definitions for the content type
+ * @param requiredLocales - Locales that should have translations
+ * @returns Translation status per locale
+ *
+ * @example
+ * ```typescript
+ * const data = {
+ *   title: { "en-US": "Hello", "es-ES": "Hola" },
+ *   content: { "en-US": "Content here" }, // missing es-ES
+ * };
+ *
+ * const status = getTranslationStatus(data, fields, ["en-US", "es-ES"]);
+ * // status: {
+ * //   "en-US": { complete: true, missingFields: [], percentage: 100 },
+ * //   "es-ES": { complete: false, missingFields: ["content"], percentage: 50 },
+ * // }
+ * ```
+ */
+export declare function getTranslationStatus(data: Record<string, unknown>, fields: FieldDefinition[], requiredLocales: string[]): Record<string, {
+    complete: boolean;
+    missingFields: string[];
+    percentage: number;
+}>;
+//# sourceMappingURL=localeFields.d.ts.map

package/dist/component/localeFields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"localeFields.d.ts","sourceRoot":"","sources":["../../src/component/localeFields.ts"],"names":[],"mappings":"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"}