@xleddyl/nuxt-cms 0.4.2 → 0.4.4

package/dist/runtime/shared/duplicate.js

@@ -0,0 +1,54 @@
+import { CONTENT_PUBLISHED_AT_FIELD, isCollectionKind, isTranslatableField } from "./index.js";
+export const DUPLICATE_TITLE_SUFFIX = " (copy)";
+const DUPLICATE_TOKEN_LENGTH = 4;
+const DUPLICATE_TOKEN_ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789";
+const COPIED_SLUG = new RegExp(`-copy-[a-z0-9]{${DUPLICATE_TOKEN_LENGTH}}$`);
+export function isUniqueField(field) {
+  return field.type === "slug" || field.type === "relation" && field.cardinality === "one-to-one";
+}
+export function uniqueFieldKeys(entry) {
+  return Object.keys(entry.fields).filter((key) => isUniqueField(entry.fields[key]));
+}
+export function duplicateToken() {
+  const bytes = new Uint8Array(DUPLICATE_TOKEN_LENGTH);
+  globalThis.crypto.getRandomValues(bytes);
+  return [...bytes].map((byte) => DUPLICATE_TOKEN_ALPHABET[byte % DUPLICATE_TOKEN_ALPHABET.length]).join("");
+}
+export function duplicateSlug(value, token) {
+  return `${value.replace(COPIED_SLUG, "")}-copy-${token}`;
+}
+function suffixTitle(field, value) {
+  if (typeof value === "string") return value.trim() ? `${value}${DUPLICATE_TITLE_SUFFIX}` : value;
+  if (!value || typeof value !== "object" || !isTranslatableField(field)) return value;
+  return Object.fromEntries(
+    Object.entries(value).map(([locale, text]) => [
+      locale,
+      typeof text === "string" && text.trim() ? `${text}${DUPLICATE_TITLE_SUFFIX}` : text
+    ])
+  );
+}
+export function duplicateFormKeys(entry) {
+  const keys = Object.keys(entry.fields);
+  return isCollectionKind(entry) && entry.drafts && !keys.includes("status") ? [...keys, "status"] : keys;
+}
+export function duplicateEntryValues(entry, source, token = duplicateToken()) {
+  const picked = Object.fromEntries(
+    duplicateFormKeys(entry).map((key) => [key, source[key] ?? null])
+  );
+  const copy = JSON.parse(JSON.stringify(picked));
+  for (const [key, field] of Object.entries(entry.fields)) {
+    if (field.type === "slug") {
+      const slug = copy[key];
+      copy[key] = typeof slug === "string" && slug ? duplicateSlug(slug, token) : null;
+    } else if (isUniqueField(field)) {
+      copy[key] = null;
+    }
+  }
+  const titleField = entry.titleField ? entry.fields[entry.titleField] : void 0;
+  if (entry.titleField && titleField?.type === "text")
+    copy[entry.titleField] = suffixTitle(titleField, copy[entry.titleField]);
+  if (entry.kind === "content" && Object.hasOwn(copy, CONTENT_PUBLISHED_AT_FIELD))
+    copy[CONTENT_PUBLISHED_AT_FIELD] = null;
+  if (isCollectionKind(entry) && entry.drafts) copy.status = "draft";
+  return copy;
+}

package/dist/runtime/shared/index.d.ts

@@ -80,7 +80,44 @@ export interface BlockConfig {
     icon?: string;
     description?: string;
     fields: Record<string, FieldConfig>;
+    validate?: CmsBlockValidate;
 }
+export type CmsValidationLevel = 'error' | 'warning';
+export interface CmsValidationIssue {
+    field?: string;
+    message: string;
+    level?: CmsValidationLevel;
+}
+export interface CmsValidateContext {
+    locales: string[];
+    defaultLocale: string;
+    path?: string;
+}
+export interface CmsBlockValidateContext extends CmsValidateContext {
+    index: number;
+}
+export type CmsValidateResult = readonly CmsValidationIssue[] | null | undefined | void;
+export type CmsValidate = (values: Record<string, unknown>, context: CmsValidateContext) => CmsValidateResult;
+export type CmsBlockValidate = (values: Record<string, unknown>, context: CmsBlockValidateContext) => CmsValidateResult;
+export interface SelectOption {
+    value: string;
+    label: string;
+}
+export type SelectOptionInput = string | {
+    readonly value: string;
+    readonly label: string;
+};
+export type CmsSelectOptionValue<O> = O extends string ? O : O extends {
+    readonly value: infer V extends string;
+} ? V : never;
+export type CmsSelectValue<F extends {
+    readonly options: readonly unknown[];
+}> = CmsSelectOptionValue<F['options'][number]>;
+export declare function selectOptions(field: Pick<FieldConfig, 'options'>): SelectOption[];
+export declare function selectOptionValues(field: Pick<FieldConfig, 'options'>): string[];
+export declare function selectOptionLabel(field: Pick<FieldConfig, 'options'>, value: unknown): string;
+export declare function selectValuesMatching(field: Pick<FieldConfig, 'options'>, term: string): string[];
+export declare function selectDisplayValue(field: Pick<FieldConfig, 'options'>, value: unknown): string;
 export type ConditionValue = string | number | boolean;
 export interface FieldCondition {
     field: string;
@@ -102,10 +139,12 @@ export interface FieldConfig {
     textarea?: boolean;
     integer?: boolean;
     translatable?: boolean;
-    options?: string[];
+    options?: readonly SelectOptionInput[];
     multiple?: boolean;
     from?: string;
     blocks?: Record<string, BlockConfig>;
+    min?: number;
+    max?: number;
     mediaType?: MediaType | MediaType[];
     accept?: string[];
     mobile?: boolean;
@@ -121,6 +160,7 @@ export declare function fieldConditions(field: FieldConfig): FieldCondition[];
 export declare function isFieldVisible(field: FieldConfig, values: Record<string, unknown> | null | undefined): boolean;
 export declare function isTranslatableField(field: FieldConfig): boolean;
 export declare function isTranslatableMediaField(field: FieldConfig): boolean;
+export declare function defaultLocaleValue(value: unknown, defaultLocale: string): string | null;
 export declare function decodeTranslatableValue(value: unknown, defaultLocale: string): Record<string, string> | null;
 export declare const decodeTranslatableMedia: typeof decodeTranslatableValue;
 export declare function encodeTranslatableMedia(value: unknown): string | null;
@@ -132,6 +172,7 @@ export declare function isMultiSelect(field: FieldConfig): boolean;
 export declare function translatableFieldKeys(entry: EntryLike): string[];
 export declare function translatableBlockFieldKeys(block: BlockConfig): string[];
 export declare function hasTranslatableBlockFields(field: FieldConfig): boolean;
+export declare function canAddBlock(field: Pick<FieldConfig, 'max'>, count: number): boolean;
 export declare const BLOCK_HIDDEN_KEY = "hidden";
 export declare function declaresHiddenField(block: BlockConfig | undefined): boolean;
 export declare function isHiddenBlock(item: unknown): boolean;
@@ -168,6 +209,7 @@ export interface CmsEntry {
     blocks?: Record<string, BlockConfig>;
     preview?: CmsPreviewOptions;
     declared?: CmsContentDeclared;
+    validate?: CmsValidate;
 }
 export interface CmsPreviewOptions {
     component?: string;
@@ -258,7 +300,7 @@ export interface SlugFieldInput extends FieldInputBase {
 }
 export interface SelectFieldInput extends FieldInputBase {
     type: 'select';
-    options: string[];
+    options: readonly SelectOptionInput[];
     multiple?: boolean;
 }
 export interface JsonFieldInput extends FieldInputBase {
@@ -285,10 +327,13 @@ export interface BlockInput {
     icon?: string;
     description?: string;
     fields: Record<string, BlockFieldInput>;
+    validate?: CmsBlockValidate;
 }
 export interface BlocksFieldInput extends FieldInputBase {
     type: 'blocks';
     blocks: Record<string, BlockInput>;
+    min?: number;
+    max?: number;
 }
 export type CmsFieldInput = TextFieldInput | RichtextFieldInput | NumberFieldInput | BooleanFieldInput | DateFieldInput | DateTimeFieldInput | EmailFieldInput | SlugFieldInput | SelectFieldInput | JsonFieldInput | MediaFieldInput | RelationFieldInput | BlocksFieldInput;
 interface CmsEntryInputBase {
@@ -300,6 +345,7 @@ interface CmsEntryInputBase {
     drafts?: boolean;
     tabs?: CmsTab[];
     fields: Record<string, CmsFieldInput>;
+    validate?: CmsValidate;
 }
 export interface CmsCollectionInput extends CmsEntryInputBase {
     kind: 'collection';
@@ -333,6 +379,7 @@ export interface CmsContentInput {
     layout?: CmsLayoutBlock[];
     list?: CmsListInput;
     preview?: CmsPreviewOptions;
+    validate?: CmsValidate;
     titleField?: never;
     drafts?: never;
 }

package/dist/runtime/shared/index.js

@@ -123,6 +123,31 @@ export function groupMediaUsage(usage) {
 export function mediaUsageGroups(usage, keys) {
   return [...new Set(keys)].map((key) => ({ key, entries: groupMediaUsage(usage[key] ?? []) })).filter((group) => group.entries.length > 0);
 }
+export function selectOptions(field) {
+  return (field.options ?? []).map(
+    (option) => typeof option === "string" ? { value: option, label: option } : {
+      value: String(option?.value ?? ""),
+      label: String(option?.label ?? option?.value ?? "")
+    }
+  );
+}
+export function selectOptionValues(field) {
+  return selectOptions(field).map((option) => option.value);
+}
+export function selectOptionLabel(field, value) {
+  const text = String(value);
+  return selectOptions(field).find((option) => option.value === text)?.label ?? text;
+}
+export function selectValuesMatching(field, term) {
+  const needle = term.trim().toLowerCase();
+  if (!needle) return [];
+  return selectOptions(field).filter((option) => option.label !== option.value).filter((option) => option.label.toLowerCase().includes(needle)).map((option) => option.value);
+}
+export function selectDisplayValue(field, value) {
+  if (value == null) return "";
+  if (Array.isArray(value)) return value.map((item) => selectOptionLabel(field, item)).join(", ");
+  return selectOptionLabel(field, value);
+}
 export function isPrivateField(field) {
   return !!field.private;
 }
@@ -159,6 +184,11 @@ function parseJsonObject(raw) {
   }
   return null;
 }
+export function defaultLocaleValue(value, defaultLocale) {
+  const values = decodeTranslatableValue(value, defaultLocale);
+  const text = values?.[defaultLocale];
+  return typeof text === "string" ? text : null;
+}
 export function decodeTranslatableValue(value, defaultLocale) {
   if (value == null) return null;
   if (typeof value === "object") return value;
@@ -219,6 +249,9 @@ export function hasTranslatableBlockFields(field) {
     (block) => Object.values(block.fields).some(isTranslatableField)
   );
 }
+export function canAddBlock(field, count) {
+  return field.max === void 0 || count < field.max;
+}
 export const BLOCK_HIDDEN_KEY = "hidden";
 export function declaresHiddenField(block) {
   return !!block && Object.hasOwn(block.fields, BLOCK_HIDDEN_KEY);

package/dist/runtime/shared/layout.d.ts

@@ -19,6 +19,7 @@ export interface CmsFormLayout {
 }
 export interface CmsListInput {
     columns?: string[];
+    filters?: string[];
 }
 export interface CmsEntrySettings {
     columns?: string[];
@@ -30,4 +31,6 @@ export declare function resolveFormLayout(fields: Record<string, FieldConfig>, l
 export declare function defaultListColumns(fields: Record<string, FieldConfig>, list: CmsListInput | undefined, extra?: string[]): string[];
 export declare function resolveListColumns(fields: Record<string, FieldConfig>, saved: string[] | undefined, list: CmsListInput | undefined, extra?: string[]): string[];
 export declare function layoutErrors(at: string, fields: Record<string, FieldConfig>, input: CmsLayoutBlock[] | undefined): string[];
+export declare function isListFilterField(field: FieldConfig): boolean;
+export declare function listFilterKeys(fields: Record<string, FieldConfig>, list: CmsListInput | undefined, extra?: string[], columns?: string[]): string[];
 export declare function listErrors(at: string, fields: Record<string, FieldConfig>, list: CmsListInput | undefined, extra?: string[]): string[];

package/dist/runtime/shared/layout.js

@@ -121,7 +121,40 @@ export function layoutErrors(at, fields, input) {
   }
   return errors;
 }
+export function isListFilterField(field) {
+  if (field.type === "boolean") return true;
+  if (field.type === "select") return !field.multiple;
+  if (field.type === "relation") return field.cardinality !== "many-to-many";
+  return false;
+}
+export function listFilterKeys(fields, list, extra = [], columns) {
+  const eligible = [
+    ...Object.keys(fields).filter((key) => isListFilterField(fields[key])),
+    ...extra.filter((key) => !Object.hasOwn(fields, key))
+  ];
+  if (Array.isArray(list?.filters))
+    return [...new Set(list.filters.filter((key) => eligible.includes(key)))];
+  return columns ? eligible.filter((key) => columns.includes(key)) : eligible;
+}
 export function listErrors(at, fields, list, extra = []) {
-  if (!list?.columns) return [];
-  return list.columns.filter((key) => !Object.hasOwn(fields, key) && !extra.includes(key)).map((key) => `${at}: list.columns names '${key}', which is not a declared field`);
+  const errors = [];
+  for (const key of list?.columns ?? []) {
+    if (!Object.hasOwn(fields, key) && !extra.includes(key))
+      errors.push(`${at}: list.columns names '${key}', which is not a declared field`);
+  }
+  if (list?.filters === void 0) return errors;
+  if (!Array.isArray(list.filters)) {
+    errors.push(`${at}: list.filters must be an array of field names`);
+    return errors;
+  }
+  for (const key of list.filters) {
+    const field = Object.hasOwn(fields, key) ? fields[key] : void 0;
+    if (!field && extra.includes(key)) continue;
+    if (!field) errors.push(`${at}: list.filters names '${key}', which is not a declared field`);
+    else if (!isListFilterField(field))
+      errors.push(
+        `${at}: list.filters names '${key}', which is not a single select, boolean or single relation field`
+      );
+  }
+  return errors;
 }

package/dist/runtime/shared/list-filters.d.ts

@@ -0,0 +1,20 @@
+import type { CmsEntry, SelectOption } from './index.js';
+export declare const LIST_FILTER_PREFIX = "filter.";
+export declare const LIST_FILTER_STATUS = "status";
+export declare const LIST_FILTER_ID_MAX = 256;
+export type CmsListFilters = Record<string, string>;
+type FilterEntry = Pick<CmsEntry, 'kind' | 'fields' | 'drafts' | 'list'>;
+export declare function listFilterExtras(entry: FilterEntry): string[];
+export declare function entryListFilterKeys(entry: FilterEntry, columns?: string[]): string[];
+export declare function listFilterLabel(entry: FilterEntry, key: string): string;
+export declare function listFilterOptions(entry: FilterEntry, key: string): SelectOption[] | null;
+export declare function listFilterValueLabel(entry: FilterEntry, key: string, value: string): string;
+export declare function readListFilterQuery(query: Record<string, unknown>): Record<string, unknown>;
+export interface ListFilterParseResult {
+    filters: CmsListFilters;
+    errors: string[];
+}
+export declare function parseListFilters(entry: FilterEntry, query: Record<string, unknown>): ListFilterParseResult;
+export declare function listFilterQuery(filters: CmsListFilters): Record<string, string>;
+export declare function withoutListFilterQuery<T extends Record<string, unknown>>(query: T): Partial<T>;
+export {};

package/dist/runtime/shared/list-filters.js

@@ -0,0 +1,83 @@
+import { isCollectionKind, listFilterKeys, selectOptions } from "./index.js";
+export const LIST_FILTER_PREFIX = "filter.";
+export const LIST_FILTER_STATUS = "status";
+export const LIST_FILTER_ID_MAX = 256;
+const STATUS_OPTIONS = [
+  { value: "draft", label: "Draft" },
+  { value: "published", label: "Published" }
+];
+const BOOLEAN_OPTIONS = [
+  { value: "true", label: "Yes" },
+  { value: "false", label: "No" }
+];
+function isStatusFilter(entry, key) {
+  return key === LIST_FILTER_STATUS && !Object.hasOwn(entry.fields, key);
+}
+export function listFilterExtras(entry) {
+  return isCollectionKind(entry) && entry.drafts ? [LIST_FILTER_STATUS] : [];
+}
+export function entryListFilterKeys(entry, columns) {
+  if (!isCollectionKind(entry)) return [];
+  return listFilterKeys(entry.fields, entry.list, listFilterExtras(entry), columns);
+}
+export function listFilterLabel(entry, key) {
+  if (isStatusFilter(entry, key)) return "Status";
+  return entry.fields[key]?.label ?? key;
+}
+export function listFilterOptions(entry, key) {
+  if (isStatusFilter(entry, key)) return STATUS_OPTIONS;
+  const field = entry.fields[key];
+  if (field?.type === "select") return selectOptions(field);
+  if (field?.type === "boolean") return BOOLEAN_OPTIONS;
+  return null;
+}
+export function listFilterValueLabel(entry, key, value) {
+  return listFilterOptions(entry, key)?.find((option) => option.value === value)?.label ?? value;
+}
+export function readListFilterQuery(query) {
+  const raw = {};
+  for (const [name, value] of Object.entries(query)) {
+    if (!name.startsWith(LIST_FILTER_PREFIX)) continue;
+    const key = name.slice(LIST_FILTER_PREFIX.length);
+    if (key) raw[key] = value;
+  }
+  return raw;
+}
+export function parseListFilters(entry, query) {
+  const allowed = new Set(entryListFilterKeys(entry));
+  const filters = {};
+  const errors = [];
+  for (const [key, raw] of Object.entries(readListFilterQuery(query))) {
+    if (!allowed.has(key)) {
+      errors.push(`Unknown filter '${key}'`);
+      continue;
+    }
+    if (typeof raw !== "string") {
+      errors.push(`Filter '${key}' takes one value`);
+      continue;
+    }
+    const value = raw.trim();
+    if (!value) continue;
+    const options = listFilterOptions(entry, key);
+    if (options && !options.some((option) => option.value === value)) {
+      errors.push(`Invalid value for filter '${key}'`);
+      continue;
+    }
+    if (!options && value.length > LIST_FILTER_ID_MAX) {
+      errors.push(`Invalid value for filter '${key}'`);
+      continue;
+    }
+    filters[key] = value;
+  }
+  return { filters, errors };
+}
+export function listFilterQuery(filters) {
+  return Object.fromEntries(
+    Object.entries(filters).filter(([, value]) => typeof value === "string" && value !== "").map(([key, value]) => [`${LIST_FILTER_PREFIX}${key}`, value])
+  );
+}
+export function withoutListFilterQuery(query) {
+  return Object.fromEntries(
+    Object.entries(query).filter(([name]) => !name.startsWith(LIST_FILTER_PREFIX))
+  );
+}

package/dist/runtime/shared/transfer.d.ts

@@ -0,0 +1,70 @@
+import type { CmsEntry, CmsI18n, FieldConfig } from './index.js';
+export type CmsTransferFormat = 'json' | 'csv';
+export type CmsImportMode = 'create' | 'upsert';
+export declare const TRANSFER_FORMATS: CmsTransferFormat[];
+export declare const IMPORT_MODES: CmsImportMode[];
+export declare const IMPORT_MAX_BYTES: number;
+export declare const IMPORT_MAX_ROWS = 2000;
+export declare const IMPORT_ID_PATTERN: RegExp;
+export declare const TRANSFER_ID_KEY = "id";
+export declare const TRANSFER_TIMESTAMP_KEYS: readonly ["createdAt", "updatedAt"];
+type TransferEntry = Pick<CmsEntry, 'kind' | 'fields' | 'drafts'>;
+export interface CmsImportIssue {
+    path: string;
+    message: string;
+}
+export interface CmsImportSourceRow {
+    index: number;
+    values: Record<string, unknown>;
+    errors: CmsImportIssue[];
+}
+export interface CmsImportSource {
+    rows: CmsImportSourceRow[];
+    errors: string[];
+}
+export type CmsImportAction = 'create' | 'update';
+export interface CmsImportPreviewRow {
+    index: number;
+    id: string | null;
+    action: CmsImportAction;
+    title: string | null;
+    errors: CmsImportIssue[];
+}
+export interface CmsImportPreview {
+    format: CmsTransferFormat;
+    mode: CmsImportMode;
+    total: number;
+    valid: number;
+    create: number;
+    update: number;
+    errors: string[];
+    rows: CmsImportPreviewRow[];
+    imported: boolean;
+}
+export interface CmsExportFile {
+    collection: string;
+    exportedAt: string;
+    total: number;
+    items: Record<string, unknown>[];
+}
+export declare function canTransferCsv(entry: Pick<CmsEntry, 'fields'>): boolean;
+export declare function transferKeys(entry: TransferEntry): string[];
+export declare function exportRow(entry: TransferEntry, row: Record<string, unknown>): Record<string, unknown>;
+export declare function exportFileName(name: string, format: CmsTransferFormat, now?: Date): string;
+export declare function csvColumns(entry: TransferEntry, i18n: CmsI18n): string[];
+export declare function encodeCsvCell(value: string): string;
+export declare function encodeCsv(rows: string[][]): string;
+export declare function parseCsv(text: string): string[][];
+export declare function entryRowsToCsv(entry: TransferEntry, rows: Record<string, unknown>[], i18n: CmsI18n): string;
+type CellResult = {
+    value: unknown;
+} | {
+    error: string;
+};
+export declare function csvCellValue(field: FieldConfig, text: string): CellResult;
+export declare function csvImportSource(entry: TransferEntry, text: string, i18n: CmsI18n): CmsImportSource;
+export declare function jsonImportSource(entry: TransferEntry, text: string): CmsImportSource;
+export declare function importSource(entry: TransferEntry, format: CmsTransferFormat, text: string, i18n: CmsI18n): CmsImportSource;
+export declare function importRowTitle(entry: Pick<CmsEntry, 'fields' | 'titleField'>, values: Record<string, unknown>, defaultLocale: string): string | null;
+export declare function importIssuePath(path: readonly PropertyKey[]): string;
+export {};