@xleddyl/nuxt-cms 0.9.3 → 0.10.0

package/dist/runtime/shared/block-paths.d.ts

@@ -0,0 +1,66 @@
+import type { BlockConfig, FieldConfig } from './index.js';
+export declare const MAX_BLOCKS_DEPTH = 3;
+export type CmsBlockPathSegment = string | number;
+export type CmsBlockPath = readonly CmsBlockPathSegment[];
+type Values = Record<string, unknown>;
+type Item = Record<string, unknown>;
+export declare function isBlockItemPath(path: CmsBlockPath): boolean;
+export declare function isBlockListPath(path: CmsBlockPath): boolean;
+export declare function formatBlockPath(path: CmsBlockPath): string;
+export declare function blockReferenceLabel(path: CmsBlockPath, fieldKey?: string): string;
+export declare function parseBlockPath(text: unknown): CmsBlockPath | null;
+export declare function blockPathDepth(path: CmsBlockPath): number;
+export declare function blockListPath(itemPath: CmsBlockPath): CmsBlockPath;
+export declare function blockPathIndex(itemPath: CmsBlockPath): number;
+export declare function parentBlockPath(path: CmsBlockPath): CmsBlockPath | null;
+export declare function childBlockPath(itemPath: CmsBlockPath, fieldKey: string, index?: number): CmsBlockPath;
+export declare function blockPathStartsWith(path: CmsBlockPath, prefix: CmsBlockPath): boolean;
+export declare function sameBlockPath(a: CmsBlockPath | null, b: CmsBlockPath | null): boolean;
+export declare function blocksFieldAt(fields: Record<string, FieldConfig>, values: Values | null | undefined, listPath: CmsBlockPath): FieldConfig | null;
+export declare function blockSchemaPath(fields: Record<string, FieldConfig>, values: Values | null | undefined, path: CmsBlockPath): string[] | null;
+export declare function blockListAt(values: Values | null | undefined, listPath: CmsBlockPath): Item[] | null;
+export declare function blockAt(values: Values | null | undefined, itemPath: CmsBlockPath): Item | null;
+export interface CmsBlockLocation {
+    path: CmsBlockPath;
+    index: number;
+    depth: number;
+    item: Item;
+    field: FieldConfig;
+    block: BlockConfig | undefined;
+}
+export declare function resolveBlockPath(fields: Record<string, FieldConfig>, values: Values | null | undefined, itemPath: CmsBlockPath): CmsBlockLocation | null;
+export declare function updateBlockList(values: Values, listPath: CmsBlockPath, update: (list: Item[]) => Item[] | null): Values;
+export declare function updateBlockAt(values: Values, itemPath: CmsBlockPath, update: (item: Item) => Item): Values;
+export declare function insertBlocks(values: Values, listPath: CmsBlockPath, index: number, items: readonly Item[]): Values;
+export declare function removeBlock(values: Values, itemPath: CmsBlockPath): Values;
+export declare function pathAfterRemove(path: CmsBlockPath, removed: CmsBlockPath): CmsBlockPath | null;
+export declare function pathAfterInsert(path: CmsBlockPath, listPath: CmsBlockPath, index: number, count?: number): CmsBlockPath;
+export declare function movedBlockPath(from: CmsBlockPath, toList: CmsBlockPath, toIndex: number): CmsBlockPath | null;
+export declare function pathAfterMove(path: CmsBlockPath, from: CmsBlockPath, toList: CmsBlockPath, toIndex: number): CmsBlockPath;
+export interface CmsInsertionPoint {
+    list: CmsBlockPath;
+    index: number;
+}
+export declare function remapInsertionPoint(point: CmsInsertionPoint, remap: (path: CmsBlockPath) => CmsBlockPath | null): CmsInsertionPoint | null;
+export declare function moveBlock(values: Values, from: CmsBlockPath, toList: CmsBlockPath, toIndex: number): Values;
+export interface CmsBlockVisit {
+    item: Item;
+    block: BlockConfig;
+    field: FieldConfig;
+    path: CmsBlockPath;
+    schemaPath: readonly string[];
+    index: number;
+    depth: number;
+}
+export declare function walkBlocks(fields: Record<string, FieldConfig>, values: Values | null | undefined, visit: (visit: CmsBlockVisit) => boolean | void, prefix?: CmsBlockPath, schemaPrefix?: readonly string[]): void;
+export declare function blocksFieldAtSchemaPath(fields: Record<string, FieldConfig>, schemaPath: string | readonly string[]): FieldConfig | null;
+export interface CmsBlocksFieldVisit {
+    field: FieldConfig;
+    schemaPath: readonly string[];
+    depth: number;
+}
+export declare function blocksFieldPaths(fields: Record<string, FieldConfig>, prefix?: readonly string[]): CmsBlocksFieldVisit[];
+export declare function mapBlocks(field: FieldConfig, value: unknown, map: (item: Item, block: BlockConfig | undefined, field: FieldConfig) => Item | null): unknown;
+export declare function hasNestedBlocks(field: FieldConfig): boolean;
+export declare function blockFieldsDeep(field: FieldConfig): FieldConfig[];
+export {};

package/dist/runtime/shared/block-paths.js

@@ -0,0 +1,310 @@
+export const MAX_BLOCKS_DEPTH = 3;
+const FIELD_SEGMENT = /^[a-z_]\w*$/i;
+const INDEX_SEGMENT = /^\d+$/;
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isFieldSegment(segment) {
+  return typeof segment === "string" && FIELD_SEGMENT.test(segment);
+}
+function isIndexSegment(segment) {
+  return typeof segment === "number" && Number.isInteger(segment) && segment >= 0;
+}
+function isAlternating(path) {
+  return path.every(
+    (segment, position) => position % 2 === 0 ? isFieldSegment(segment) : isIndexSegment(segment)
+  );
+}
+export function isBlockItemPath(path) {
+  return path.length >= 2 && path.length % 2 === 0 && isAlternating(path);
+}
+export function isBlockListPath(path) {
+  return path.length >= 1 && path.length % 2 === 1 && isAlternating(path);
+}
+export function formatBlockPath(path) {
+  return path.join(".");
+}
+export function blockReferenceLabel(path, fieldKey) {
+  const base = path.map((segment) => typeof segment === "number" ? `[${segment}]` : `.${segment}`).join("").replace(/^\./, "");
+  return fieldKey ? `${base}.${fieldKey}` : base;
+}
+export function parseBlockPath(text) {
+  if (typeof text !== "string" || !text) return null;
+  const path = text.split(".").map((segment) => INDEX_SEGMENT.test(segment) ? Number(segment) : segment);
+  return isAlternating(path) ? path : null;
+}
+export function blockPathDepth(path) {
+  return Math.ceil(path.length / 2);
+}
+export function blockListPath(itemPath) {
+  return itemPath.slice(0, -1);
+}
+export function blockPathIndex(itemPath) {
+  const last = itemPath.at(-1);
+  return isIndexSegment(last) ? last : -1;
+}
+export function parentBlockPath(path) {
+  const list = path.length % 2 === 0 ? path.slice(0, -1) : path;
+  return list.length >= 3 ? list.slice(0, -1) : null;
+}
+export function childBlockPath(itemPath, fieldKey, index) {
+  return index === void 0 ? [...itemPath, fieldKey] : [...itemPath, fieldKey, index];
+}
+export function blockPathStartsWith(path, prefix) {
+  return prefix.length <= path.length && prefix.every((segment, i) => path[i] === segment);
+}
+export function sameBlockPath(a, b) {
+  if (!a || !b) return a === b;
+  return a.length === b.length && blockPathStartsWith(a, b);
+}
+function locateList(fields, values, listPath) {
+  if (!isBlockListPath(listPath)) return null;
+  const schemaPath = [];
+  let scope = fields;
+  let current = values;
+  for (let position = 0; position < listPath.length; position += 2) {
+    const key = listPath[position];
+    const field = Object.hasOwn(scope, key) ? scope[key] : void 0;
+    if (field?.type !== "blocks") return null;
+    schemaPath.push(key);
+    if (position === listPath.length - 1) return { field, schemaPath };
+    const list = isRecord(current) ? current[key] : void 0;
+    const item = Array.isArray(list) ? list[listPath[position + 1]] : void 0;
+    const block = isRecord(item) ? field.blocks?.[String(item.type)] : void 0;
+    if (!block || !isRecord(item)) return null;
+    schemaPath.push(String(item.type));
+    scope = block.fields;
+    current = item;
+  }
+  return null;
+}
+export function blocksFieldAt(fields, values, listPath) {
+  return locateList(fields, values, listPath)?.field ?? null;
+}
+export function blockSchemaPath(fields, values, path) {
+  return locateList(fields, values, path.length % 2 === 0 ? path.slice(0, -1) : path)?.schemaPath ?? null;
+}
+export function blockListAt(values, listPath) {
+  if (!isBlockListPath(listPath)) return null;
+  let current = values;
+  for (let position = 0; position < listPath.length; position++) {
+    const segment = listPath[position];
+    if (position % 2 === 0) {
+      if (!isRecord(current)) return null;
+      current = current[segment];
+    } else {
+      current = Array.isArray(current) ? current[segment] : void 0;
+    }
+  }
+  return Array.isArray(current) ? current : null;
+}
+export function blockAt(values, itemPath) {
+  if (!isBlockItemPath(itemPath)) return null;
+  const item = blockListAt(values, blockListPath(itemPath))?.[blockPathIndex(itemPath)];
+  return isRecord(item) ? item : null;
+}
+export function resolveBlockPath(fields, values, itemPath) {
+  const item = blockAt(values, itemPath);
+  const field = item ? blocksFieldAt(fields, values, blockListPath(itemPath)) : null;
+  if (!item || !field) return null;
+  return {
+    path: itemPath,
+    index: blockPathIndex(itemPath),
+    depth: blockPathDepth(itemPath),
+    item,
+    field,
+    block: field.blocks?.[String(item.type)]
+  };
+}
+function updateIn(current, path, update) {
+  if (!path.length) {
+    const next2 = update(Array.isArray(current) ? current : []);
+    return next2 && next2.length ? next2 : null;
+  }
+  const [segment, ...rest] = path;
+  if (typeof segment === "string") {
+    if (!isRecord(current)) return current;
+    const next2 = updateIn(current[segment], rest, update);
+    return next2 === current[segment] ? current : { ...current, [segment]: next2 };
+  }
+  if (!Array.isArray(current) || !isRecord(current[segment])) return current;
+  const next = updateIn(current[segment], rest, update);
+  if (next === current[segment]) return current;
+  const copy = [...current];
+  copy[segment] = next;
+  return copy;
+}
+export function updateBlockList(values, listPath, update) {
+  if (!isBlockListPath(listPath)) return values;
+  return updateIn(values, listPath, update);
+}
+export function updateBlockAt(values, itemPath, update) {
+  if (!blockAt(values, itemPath)) return values;
+  const index = blockPathIndex(itemPath);
+  return updateBlockList(values, blockListPath(itemPath), (list) => {
+    const next = [...list];
+    next[index] = update(list[index]);
+    return next;
+  });
+}
+export function insertBlocks(values, listPath, index, items) {
+  if (!items.length) return values;
+  if (listPath.length > 1 && !blockAt(values, listPath.slice(0, -1))) return values;
+  return updateBlockList(values, listPath, (list) => {
+    const next = [...list];
+    next.splice(Math.min(Math.max(index, 0), list.length), 0, ...items);
+    return next;
+  });
+}
+export function removeBlock(values, itemPath) {
+  if (!blockAt(values, itemPath)) return values;
+  const index = blockPathIndex(itemPath);
+  return updateBlockList(
+    values,
+    blockListPath(itemPath),
+    (list) => list.filter((_, position) => position !== index)
+  );
+}
+export function pathAfterRemove(path, removed) {
+  const list = blockListPath(removed);
+  const index = blockPathIndex(removed);
+  if (path.length <= list.length || !blockPathStartsWith(path, list)) return path;
+  const position = path[list.length];
+  if (position === index) return null;
+  if (position < index) return path;
+  const next = [...path];
+  next[list.length] = position - 1;
+  return next;
+}
+export function pathAfterInsert(path, listPath, index, count = 1) {
+  if (path.length <= listPath.length || !blockPathStartsWith(path, listPath)) return path;
+  const position = path[listPath.length];
+  if (position < index) return path;
+  const next = [...path];
+  next[listPath.length] = position + count;
+  return next;
+}
+export function movedBlockPath(from, toList, toIndex) {
+  if (!isBlockItemPath(from) || !isBlockListPath(toList)) return null;
+  if (blockPathStartsWith(toList, from)) return null;
+  const fromList = blockListPath(from);
+  const fromIndex = blockPathIndex(from);
+  const target = pathAfterRemove(toList, from);
+  if (!target) return null;
+  const sameList = sameBlockPath(fromList, toList);
+  const index = Math.max(sameList && toIndex > fromIndex ? toIndex - 1 : toIndex, 0);
+  if (sameList && index === fromIndex) return null;
+  return [...target, index];
+}
+export function pathAfterMove(path, from, toList, toIndex) {
+  const moved = movedBlockPath(from, toList, toIndex);
+  if (!moved) return path;
+  if (blockPathStartsWith(path, from)) return [...moved, ...path.slice(from.length)];
+  const removed = pathAfterRemove(path, from) ?? path;
+  return pathAfterInsert(removed, blockListPath(moved), blockPathIndex(moved));
+}
+export function remapInsertionPoint(point, remap) {
+  const slot = remap([...point.list, point.index]);
+  if (slot) return { list: blockListPath(slot), index: blockPathIndex(slot) };
+  if (point.list.length <= 1) return point;
+  const owner = remap(point.list.slice(0, -1));
+  return owner ? { list: [...owner, point.list.at(-1)], index: point.index } : null;
+}
+export function moveBlock(values, from, toList, toIndex) {
+  const item = blockAt(values, from);
+  const moved = item ? movedBlockPath(from, toList, toIndex) : null;
+  if (!item || !moved) return values;
+  const target = blockListPath(moved);
+  const removed = removeBlock(values, from);
+  if (target.length > 1 && !blockAt(removed, target.slice(0, -1))) return values;
+  return insertBlocks(removed, target, blockPathIndex(moved), [item]);
+}
+export function walkBlocks(fields, values, visit, prefix = [], schemaPrefix = []) {
+  if (!isRecord(values)) return;
+  for (const [key, field] of Object.entries(fields)) {
+    if (field?.type !== "blocks") continue;
+    const list = values[key];
+    if (!Array.isArray(list)) continue;
+    const schemaPath = [...schemaPrefix, key];
+    list.forEach((item, index) => {
+      if (!isRecord(item)) return;
+      const block = field.blocks?.[String(item.type)];
+      if (!block) return;
+      const path = [...prefix, key, index];
+      const descend = visit({
+        item,
+        block,
+        field,
+        path,
+        schemaPath,
+        index,
+        depth: blockPathDepth(path)
+      });
+      if (descend === false) return;
+      walkBlocks(block.fields, item, visit, path, [...schemaPath, String(item.type)]);
+    });
+  }
+}
+export function blocksFieldAtSchemaPath(fields, schemaPath) {
+  const segments = typeof schemaPath === "string" ? schemaPath.split(".") : schemaPath;
+  if (!segments.length || segments.length % 2 === 0) return null;
+  let scope = fields;
+  for (let position = 0; position < segments.length; position += 2) {
+    const key = segments[position];
+    const field = Object.hasOwn(scope, key) ? scope[key] : void 0;
+    if (field?.type !== "blocks") return null;
+    if (position === segments.length - 1) return field;
+    const type = segments[position + 1];
+    const block = field.blocks && Object.hasOwn(field.blocks, type) ? field.blocks[type] : void 0;
+    if (!block) return null;
+    scope = block.fields;
+  }
+  return null;
+}
+export function blocksFieldPaths(fields, prefix = []) {
+  const found = [];
+  for (const [key, field] of Object.entries(fields)) {
+    if (field?.type !== "blocks" || field.private) continue;
+    const schemaPath = [...prefix, key];
+    found.push({ field, schemaPath, depth: Math.ceil(schemaPath.length / 2) });
+    for (const [blockName, block] of Object.entries(field.blocks ?? {})) {
+      found.push(...blocksFieldPaths(block?.fields ?? {}, [...schemaPath, blockName]));
+    }
+  }
+  return found;
+}
+export function mapBlocks(field, value, map) {
+  if (!Array.isArray(value)) return value;
+  const result = [];
+  for (const item of value) {
+    if (!isRecord(item)) {
+      result.push(item);
+      continue;
+    }
+    const block = field.blocks?.[String(item.type)];
+    const mapped = map(item, block, field);
+    if (!mapped) continue;
+    let next = mapped;
+    for (const [key, subfield] of Object.entries(block?.fields ?? {})) {
+      if (subfield.type !== "blocks" || !Array.isArray(next[key])) continue;
+      const nested = mapBlocks(subfield, next[key], map);
+      if (nested === next[key]) continue;
+      if (next === item) next = { ...item };
+      next[key] = nested;
+    }
+    result.push(next);
+  }
+  return result;
+}
+export function hasNestedBlocks(field) {
+  return Object.values(field.blocks ?? {}).some(
+    (block) => Object.values(block?.fields ?? {}).some((subfield) => subfield?.type === "blocks")
+  );
+}
+export function blockFieldsDeep(field) {
+  return Object.values(field.blocks ?? {}).flatMap(
+    (block) => Object.values(block?.fields ?? {}).flatMap(
+      (subfield) => subfield?.type === "blocks" ? [subfield, ...blockFieldsDeep(subfield)] : [subfield]
+    )
+  );
+}

package/dist/runtime/shared/block-picker.d.ts

@@ -0,0 +1,18 @@
+import type { BlockConfig } from './index.js';
+export declare const CMS_BLOCK_PICKER_OTHER_GROUP = "Other";
+export declare const CMS_BLOCK_ICON = "rectangle-stack";
+export interface CmsBlockPickerItem {
+    type: string;
+    label: string;
+    description?: string;
+    icon: string;
+    keywords: string[];
+    disabled: boolean;
+    disabledReason?: string;
+}
+export interface CmsBlockPickerGroup {
+    id: string;
+    label: string | null;
+    items: CmsBlockPickerItem[];
+}
+export declare function blockPickerGroups(blocks: Record<string, BlockConfig>, disabledReason?: (type: string) => string | undefined): CmsBlockPickerGroup[];

package/dist/runtime/shared/block-picker.js

@@ -0,0 +1,31 @@
+export const CMS_BLOCK_PICKER_OTHER_GROUP = "Other";
+export const CMS_BLOCK_ICON = "rectangle-stack";
+export function blockPickerGroups(blocks, disabledReason = () => void 0) {
+  const entries = Object.entries(blocks);
+  const grouped = entries.some(([, block]) => !!block.group?.trim());
+  const groups = /* @__PURE__ */ new Map();
+  const other = {
+    id: "",
+    label: grouped ? CMS_BLOCK_PICKER_OTHER_GROUP : null,
+    items: []
+  };
+  for (const [type, block] of entries) {
+    const name = block.group?.trim();
+    let group = other;
+    if (name) {
+      group = groups.get(name) ?? { id: name, label: name, items: [] };
+      groups.set(name, group);
+    }
+    const reason = disabledReason(type) || void 0;
+    group.items.push({
+      type,
+      label: block.label,
+      description: block.description || void 0,
+      icon: block.icon ?? CMS_BLOCK_ICON,
+      keywords: [type, ...name ? [name] : [], ...block.tags ?? []],
+      disabled: !!reason,
+      ...reason ? { disabledReason: reason } : {}
+    });
+  }
+  return [...groups.values(), other].filter((group) => group.items.length);
+}

package/dist/runtime/shared/block-signature.d.ts

@@ -0,0 +1,4 @@
+import type { BlockConfig } from './index.js';
+export declare function blockShape(block: Pick<BlockConfig, 'fields'>): string;
+export declare function blockSignature(block: Pick<BlockConfig, 'fields'>): string;
+export declare function blockSignatures(blocks: Record<string, Pick<BlockConfig, 'fields'>> | undefined, types: readonly string[]): Record<string, string>;

package/dist/runtime/shared/block-signature.js

@@ -0,0 +1,46 @@
+import { isTranslatableField, mediaTypeFilter, selectOptionValues } from "./index.js";
+function fieldShape(key, field) {
+  const shape = [key, field.type];
+  if (isTranslatableField(field)) shape.push("translatable");
+  if (field.type === "number" && field.integer) shape.push("integer");
+  if (field.type === "select") {
+    if (field.multiple) shape.push("multiple");
+    shape.push({ options: [...new Set(selectOptionValues(field))].sort() });
+  }
+  if (field.type === "media")
+    shape.push({ mediaType: mediaTypeFilter(field.mediaType)?.sort() ?? null });
+  if (field.type === "blocks") {
+    const blocks = field.blocks ?? {};
+    shape.push({
+      blocks: Object.keys(blocks).sort().map((name) => [name, blockFieldShapes(blocks[name])])
+    });
+  }
+  return shape;
+}
+function blockFieldShapes(block) {
+  return Object.keys(block.fields).sort().map((key) => fieldShape(key, block.fields[key]));
+}
+export function blockShape(block) {
+  return JSON.stringify(blockFieldShapes(block));
+}
+function hashText(text) {
+  let first = 2166136261;
+  let second = 2538058380;
+  for (let index = 0; index < text.length; index++) {
+    const code = text.charCodeAt(index);
+    first = Math.imul(first ^ code, 16777619);
+    second = Math.imul(second ^ code, 1540483477);
+    second ^= second >>> 15;
+  }
+  const hex = (value) => (value >>> 0).toString(16).padStart(8, "0");
+  return `${hex(first)}${hex(second)}`;
+}
+export function blockSignature(block) {
+  return hashText(blockShape(block));
+}
+export function blockSignatures(blocks, types) {
+  const available = blocks ?? {};
+  return Object.fromEntries(
+    types.filter((type) => Object.hasOwn(available, type)).map((type) => [type, blockSignature(available[type])])
+  );
+}

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

@@ -0,0 +1,31 @@
+import type { BlockConfig, CmsI18n, FieldConfig } from './index.js';
+import type { CmsBlockValue } from './preview.js';
+export declare const CMS_CLIPBOARD_KIND = "blocks";
+export declare const CMS_CLIPBOARD_VERSION = 1;
+export declare const CMS_CLIPBOARD_MAX_ITEMS = 200;
+export interface CmsClipboardPayload {
+    nuxtCms: typeof CMS_CLIPBOARD_KIND;
+    version: typeof CMS_CLIPBOARD_VERSION;
+    items: CmsBlockValue[];
+}
+export interface CmsPasteResult {
+    list: CmsBlockValue[];
+    at: number;
+    pasted: number;
+    unknown: string[];
+    overflow: number;
+}
+export interface CmsClipboardNotice {
+    title: string;
+    description?: string;
+    color?: 'success' | 'error';
+}
+export declare function clipboardText(items: readonly CmsBlockValue[]): string;
+export declare function parseClipboardText(text: unknown): CmsBlockValue[] | null;
+export declare function pastedFieldValue(field: FieldConfig, raw: unknown, i18n: CmsI18n): unknown;
+export declare function pastedBlock(type: string, block: BlockConfig, item: Record<string, unknown>, i18n: CmsI18n): CmsBlockValue;
+export declare function pasteBlocks(list: readonly CmsBlockValue[], at: number, items: readonly CmsBlockValue[], field: Pick<FieldConfig, 'blocks' | 'max'>, i18n: CmsI18n): CmsPasteResult;
+export declare function pasteableCount(items: readonly CmsBlockValue[] | null | undefined, field: Pick<FieldConfig, 'blocks'>): number;
+export declare function skippedText(result: CmsPasteResult, field: Pick<FieldConfig, 'max'>): string | undefined;
+export declare function copyNotice(count: number, cut?: boolean): CmsClipboardNotice;
+export declare function pasteNotice(result: CmsPasteResult | null, field: Pick<FieldConfig, 'max'>): CmsClipboardNotice;