@xleddyl/nuxt-cms 0.9.4 → 0.10.1

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;

package/dist/runtime/shared/clipboard.js

@@ -0,0 +1,206 @@
+import {
+  BLOCK_HIDDEN_KEY,
+  allowsExternalLinks,
+  declaredLinkTargets,
+  declaresHiddenField,
+  isTranslatableField,
+  linkUrlError,
+  selectOptionValues
+} from "./index.js";
+import { CMS_CLIPBOARD_MAX_LENGTH } from "./preview.js";
+import { objectKeySchema } from "./validation.js";
+export const CMS_CLIPBOARD_KIND = "blocks";
+export const CMS_CLIPBOARD_VERSION = 1;
+export const CMS_CLIPBOARD_MAX_ITEMS = 200;
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isBlockItem(value) {
+  return isRecord(value) && typeof value.type === "string" && value.type !== "";
+}
+export function clipboardText(items) {
+  const payload = {
+    nuxtCms: CMS_CLIPBOARD_KIND,
+    version: CMS_CLIPBOARD_VERSION,
+    items: items.map((item) => ({ ...item }))
+  };
+  return JSON.stringify(payload);
+}
+export function parseClipboardText(text) {
+  if (typeof text !== "string" || text.length > CMS_CLIPBOARD_MAX_LENGTH) return null;
+  if (!text.trimStart().startsWith("{")) return null;
+  let data;
+  try {
+    data = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (!isRecord(data) || data.nuxtCms !== CMS_CLIPBOARD_KIND) return null;
+  if (data.version !== CMS_CLIPBOARD_VERSION || !Array.isArray(data.items)) return null;
+  const items = data.items.filter(isBlockItem).slice(0, CMS_CLIPBOARD_MAX_ITEMS);
+  return items.length ? items : null;
+}
+function isMediaKey(value) {
+  return objectKeySchema.safeParse(value).success;
+}
+function localizedShape(raw, i18n, accepts) {
+  if (typeof raw === "string") return raw && accepts(raw) ? { [i18n.defaultLocale]: raw } : null;
+  if (!isRecord(raw)) return null;
+  const entries = Object.entries(raw).filter(
+    (pair) => i18n.locales.includes(pair[0]) && accepts(pair[1])
+  );
+  return entries.length ? Object.fromEntries(entries) : null;
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function plainShape(field, raw, i18n) {
+  if (field.type === "json" || field.type === "link" || !isRecord(raw)) return raw;
+  const value = raw[i18n.defaultLocale];
+  if (typeof value === "string") return value;
+  return Object.values(raw).find((entry) => typeof entry === "string") ?? null;
+}
+function trimmedText(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function linkLabelShape(field, raw, i18n) {
+  if (!field.withLabel || raw == null) return void 0;
+  if (field.translatable && i18n.locales.length) {
+    const label = localizedShape(raw, i18n, isString);
+    if (!label) return void 0;
+    const kept = Object.entries(label).map(([locale, text2]) => [locale, text2.trim()]).filter(([, text2]) => !!text2);
+    return kept.length ? Object.fromEntries(kept) : void 0;
+  }
+  const text = trimmedText(plainShape({ ...field, type: "text" }, raw, i18n));
+  return text || void 0;
+}
+function linkShape(field, raw, i18n) {
+  if (!isRecord(raw)) return null;
+  const url = trimmedText(raw.url);
+  const entry = trimmedText(raw.entry);
+  const id = trimmedText(raw.id);
+  const label = linkLabelShape(field, raw.label, i18n);
+  const extra = {
+    ...label !== void 0 ? { label } : {},
+    ...raw.newTab === true ? { newTab: true } : {}
+  };
+  if (url && !entry && !id) {
+    if (!allowsExternalLinks(field) || linkUrlError(url)) return null;
+    return { url, ...extra };
+  }
+  if (url || !entry || !id) return null;
+  const targets = declaredLinkTargets(field);
+  if (targets && !targets.includes(entry)) return null;
+  return { entry, id, ...extra };
+}
+function scalarShape(field, raw) {
+  if (raw === void 0 || raw === null) return null;
+  switch (field.type) {
+    case "json":
+      return raw;
+    case "number":
+      return typeof raw === "number" && Number.isFinite(raw) ? raw : null;
+    case "boolean":
+      return typeof raw === "boolean" ? raw : null;
+    case "media":
+      return isMediaKey(raw) ? raw : null;
+    case "select": {
+      const options = selectOptionValues(field);
+      if (field.multiple) {
+        if (!Array.isArray(raw)) return null;
+        const values = [...new Set(raw.filter((value) => options.includes(value)))];
+        return values.length ? values : null;
+      }
+      return typeof raw === "string" && options.includes(raw) ? raw : null;
+    }
+    case "tags": {
+      if (!Array.isArray(raw)) return null;
+      const values = raw.filter(isString);
+      return values.length ? values : null;
+    }
+    default:
+      return typeof raw === "string" ? raw : null;
+  }
+}
+export function pastedFieldValue(field, raw, i18n) {
+  if (field.type === "blocks") {
+    if (!Array.isArray(raw)) return null;
+    const { list } = pasteBlocks([], 0, raw.filter(isBlockItem), field, i18n);
+    return list.length ? list : null;
+  }
+  if (field.type === "link") return linkShape(field, raw, i18n);
+  if (isTranslatableField(field) && i18n.locales.length > 0)
+    return localizedShape(raw, i18n, field.type === "media" ? isMediaKey : isString);
+  return scalarShape(field, plainShape(field, raw, i18n));
+}
+export function pastedBlock(type, block, item, i18n) {
+  const value = { type };
+  for (const [key, field] of Object.entries(block.fields))
+    value[key] = pastedFieldValue(field, item[key], i18n);
+  if (!declaresHiddenField(block) && item[BLOCK_HIDDEN_KEY] === true)
+    value[BLOCK_HIDDEN_KEY] = true;
+  return value;
+}
+export function pasteBlocks(list, at, items, field, i18n) {
+  const blocks = field.blocks ?? {};
+  const unknown = [];
+  const allowed = [];
+  for (const item of items) {
+    const type = String(item.type);
+    if (Object.hasOwn(blocks, type)) allowed.push(item);
+    else unknown.push(type);
+  }
+  const room = field.max === void 0 ? allowed.length : Math.max(field.max - list.length, 0);
+  const kept = allowed.slice(0, room);
+  const index = Math.min(Math.max(at, 0), list.length);
+  const next = [...list];
+  next.splice(
+    index,
+    0,
+    ...kept.map((item) => pastedBlock(String(item.type), blocks[String(item.type)], item, i18n))
+  );
+  return {
+    list: next,
+    at: index,
+    pasted: kept.length,
+    unknown,
+    overflow: allowed.length - kept.length
+  };
+}
+export function pasteableCount(items, field) {
+  const blocks = field.blocks ?? {};
+  return (items ?? []).filter((item) => Object.hasOwn(blocks, String(item.type))).length;
+}
+function blockCount(count) {
+  return `${count} ${count === 1 ? "block" : "blocks"}`;
+}
+export function skippedText(result, field) {
+  const parts = [];
+  if (result.unknown.length) {
+    const types = [...new Set(result.unknown)].join(", ");
+    parts.push(
+      `${blockCount(result.unknown.length)} skipped, not available in this field: ${types}.`
+    );
+  }
+  if (result.overflow) {
+    const max = field.max ?? 0;
+    parts.push(
+      `${blockCount(result.overflow)} skipped, this field holds at most ${blockCount(max)}.`
+    );
+  }
+  return parts.length ? parts.join(" ") : void 0;
+}
+export function copyNotice(count, cut = false) {
+  const what = count === 1 ? "Block" : blockCount(count);
+  return { title: `${what} ${cut ? "cut" : "copied"}` };
+}
+export function pasteNotice(result, field) {
+  if (!result) return { title: "Nothing to paste", description: "Copy or cut a block first." };
+  const description = skippedText(result, field);
+  if (!result.pasted) return { title: "Nothing pasted", description, color: "error" };
+  return {
+    title: `${result.pasted === 1 ? "Block" : blockCount(result.pasted)} pasted`,
+    description,
+    color: description ? void 0 : "success"
+  };
+}

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

@@ -0,0 +1,36 @@
+import type { FieldConfig, FieldType } from './index.js';
+export type ConditionValue = string | number | boolean;
+export interface FieldCondition {
+    field: string;
+    eq?: ConditionValue;
+    neq?: ConditionValue;
+    in?: readonly ConditionValue[];
+    notIn?: readonly ConditionValue[];
+    gt?: number | string;
+    gte?: number | string;
+    lt?: number | string;
+    lte?: number | string;
+    empty?: boolean;
+    has?: string;
+}
+export interface AllCondition {
+    all: readonly ShowIfCondition[];
+}
+export interface AnyCondition {
+    any: readonly ShowIfCondition[];
+}
+export interface NotCondition {
+    not: ShowIfCondition;
+}
+export type ShowIfCondition = FieldCondition | AllCondition | AnyCondition | NotCondition;
+export type CmsShowIf = ShowIfCondition | readonly ShowIfCondition[];
+export declare const CONDITION_OPERATORS: readonly ["eq", "neq", "in", "notIn", "gt", "gte", "lt", "lte", "empty", "has"];
+export type ConditionOperator = (typeof CONDITION_OPERATORS)[number];
+export declare const CONDITION_GROUPS: readonly ["all", "any", "not"];
+export type ConditionScope = Record<string, Pick<FieldConfig, 'type'>> | null | undefined;
+type Values = Record<string, unknown> | null | undefined;
+export declare function fieldConditions(field: FieldConfig): ShowIfCondition[];
+export declare function isEmptyConditionValue(value: unknown, type?: FieldType): boolean;
+export declare function matchesShowIf(condition: ShowIfCondition, values: Values, scope?: ConditionScope): boolean;
+export declare function isFieldVisible(field: FieldConfig, values: Values, scope?: ConditionScope): boolean;
+export {};