@crediblemark/build 0.22.0

package/dist/chunk-4SQOX3ZQ.mjs

@@ -0,0 +1,476 @@
+import {
+  styles_module_default
+} from "./chunk-IJHL7BIR.mjs";
+import {
+  defaultAppState,
+  resolveComponentData
+} from "./chunk-CDMESQDA.mjs";
+import {
+  get_class_name_factory_default
+} from "./chunk-YH7AXYKP.mjs";
+import {
+  generateId,
+  getZoneId,
+  mapFields,
+  toComponent,
+  walkAppState,
+  walkTree
+} from "./chunk-GUJDGRSM.mjs";
+import {
+  init_react_import
+} from "./chunk-B4BOBGYB.mjs";
+
+// lib/migrate.ts
+init_react_import();
+var migrations = [
+  // Migrate root to root.props
+  (data) => {
+    const rootProps = data.root.props || data.root;
+    if (Object.keys(data.root).length > 0 && !data.root.props) {
+      console.warn(
+        "Migration applied: Root props moved from `root` to `root.props`."
+      );
+      return {
+        ...data,
+        root: {
+          props: {
+            ...rootProps
+          }
+        }
+      };
+    }
+    return data;
+  },
+  // Migrate zones to slots
+  (data, config, migrationOptions) => {
+    if (!config) return data;
+    console.log("Migrating DropZones to slots...");
+    const updatedItems = {};
+    const appState = { ...defaultAppState, data };
+    const { indexes } = walkAppState(appState, config);
+    const deletedCompounds = [];
+    walkAppState(appState, config, (content, zoneCompound, zoneType) => {
+      if (zoneType === "dropzone") {
+        const [id, slotName] = zoneCompound.split(":");
+        const nodeData = indexes.nodes[id].data;
+        const componentType = nodeData.type;
+        const configForComponent = id === "root" ? config.root : config.components[componentType];
+        if (configForComponent?.fields?.[slotName]?.type === "slot") {
+          updatedItems[id] = {
+            ...nodeData,
+            props: {
+              ...nodeData.props,
+              ...updatedItems[id]?.props,
+              [slotName]: content
+            }
+          };
+          deletedCompounds.push(zoneCompound);
+        }
+        return content;
+      }
+      return content;
+    });
+    const updated = walkAppState(
+      appState,
+      config,
+      (content) => content,
+      (item) => {
+        return updatedItems[item.props.id] ?? item;
+      }
+    );
+    deletedCompounds.forEach((zoneCompound) => {
+      const [_, propName] = zoneCompound.split(":");
+      console.log(
+        `\u2713 Success: Migrated "${zoneCompound}" from DropZone to slot field "${propName}"`
+      );
+      delete updated.data.zones?.[zoneCompound];
+    });
+    if (migrationOptions?.migrateDynamicZonesForComponent) {
+      const unmigratedZonesGrouped = {};
+      Object.keys(updated.data.zones ?? {}).forEach((zoneCompound) => {
+        const [componentId, propName] = zoneCompound.split(":");
+        const content = updated.data.zones?.[zoneCompound];
+        if (!content) {
+          return;
+        }
+        if (!unmigratedZonesGrouped[componentId]) {
+          unmigratedZonesGrouped[componentId] = {};
+        }
+        if (!unmigratedZonesGrouped[componentId][propName]) {
+          unmigratedZonesGrouped[componentId][propName] = content;
+        }
+      });
+      Object.keys(unmigratedZonesGrouped).forEach((componentId) => {
+        updated.data = walkTree(updated.data, config, (content) => {
+          return content.map((child) => {
+            if (child.props.id !== componentId) {
+              return child;
+            }
+            const migrateFn = migrationOptions?.migrateDynamicZonesForComponent?.[child.type];
+            if (!migrateFn) {
+              return child;
+            }
+            const zones = unmigratedZonesGrouped[componentId];
+            const migratedProps = migrateFn(child.props, zones);
+            Object.keys(zones).forEach((propName) => {
+              const zoneCompound = `${componentId}:${propName}`;
+              console.log(`\u2713 Success: Migrated "${zoneCompound}" DropZone`);
+              delete updated.data.zones?.[zoneCompound];
+            });
+            return {
+              ...child,
+              props: migratedProps
+            };
+          });
+        });
+      });
+    }
+    Object.keys(updated.data.zones ?? {}).forEach((zoneCompound) => {
+      const [_, propName] = zoneCompound.split(":");
+      throw new Error(
+        `Could not migrate DropZone "${zoneCompound}" to slot field. No slot exists with the name "${propName}".`
+      );
+    });
+    delete updated.data.zones;
+    return updated.data;
+  }
+];
+function migrate(data, config, migrationOptions) {
+  return migrations?.reduce(
+    (acc, migration) => migration(acc, config, migrationOptions),
+    data
+  );
+}
+
+// lib/transform-props.ts
+init_react_import();
+
+// lib/data/default-data.ts
+init_react_import();
+var defaultData = (data) => ({
+  ...data,
+  root: data.root || {},
+  content: data.content || []
+});
+
+// lib/transform-props.ts
+function transformProps(data, propTransforms, config = { components: {} }) {
+  const mapItem = (item) => {
+    if (propTransforms[item.type]) {
+      return {
+        ...item,
+        props: {
+          id: item.props.id,
+          ...propTransforms[item.type](item.props)
+        }
+      };
+    }
+    return item;
+  };
+  const defaultedData = defaultData(data);
+  const rootProps = defaultedData.root.props || defaultedData.root;
+  let newRoot = { ...defaultedData.root };
+  if (propTransforms["root"]) {
+    newRoot.props = propTransforms["root"](rootProps);
+  }
+  const dataWithUpdatedRoot = { ...defaultedData, root: newRoot };
+  const updatedData = walkTree(
+    dataWithUpdatedRoot,
+    config,
+    (content) => content.map(mapItem)
+  );
+  if (!defaultedData.root.props) {
+    updatedData.root = updatedData.root.props;
+  }
+  return updatedData;
+}
+
+// lib/resolve-all-data.ts
+init_react_import();
+
+// lib/group-zones-by-component.ts
+init_react_import();
+var groupZonesByComponent = (data) => {
+  const zoneEntries = Object.entries(data.zones ?? {});
+  return zoneEntries.reduce((acc, [zoneCompound, zoneContent]) => {
+    const [componentId, zoneName] = getZoneId(zoneCompound);
+    if (!componentId.length || !zoneName.length) return acc;
+    if (!acc[componentId]) {
+      acc[componentId] = [];
+    }
+    acc[componentId].push({ zoneCompound, content: zoneContent });
+    return acc;
+  }, {});
+};
+
+// lib/resolve-all-data.ts
+async function resolveAllData(data, config, metadata = {}, onResolveStart, onResolveEnd) {
+  const defaultedData = defaultData(data);
+  const zonesByComponent = groupZonesByComponent(defaultedData);
+  let resolvedZones = {};
+  const resolveNode = async (_node, parent) => {
+    const node = toComponent(_node);
+    onResolveStart?.(node);
+    const resolved = (await resolveComponentData(
+      node,
+      config,
+      metadata,
+      () => {
+      },
+      () => {
+      },
+      "force",
+      parent
+    )).node;
+    const resolvedAsComponent = toComponent(resolved);
+    const resolvedDeepPromise = mapFields(
+      resolved,
+      {
+        slot: ({ value }) => processContent(value, resolvedAsComponent)
+      },
+      config
+    );
+    let resolveZonePromises = [];
+    if (zonesByComponent[resolvedAsComponent.props.id]) {
+      resolveZonePromises = zonesByComponent[resolvedAsComponent.props.id].map(
+        async ({ zoneCompound, content }) => {
+          resolvedZones[zoneCompound] = await processContent(
+            content,
+            resolvedAsComponent
+          );
+        }
+      );
+    }
+    const resolvedDeep = await resolvedDeepPromise;
+    await Promise.all(resolveZonePromises);
+    onResolveEnd?.(toComponent(resolvedDeep));
+    return resolvedDeep;
+  };
+  const processContent = async (content, parent) => {
+    return Promise.all(content.map((item) => resolveNode(item, parent)));
+  };
+  const result = defaultData({});
+  result.root = await resolveNode(defaultedData.root, null);
+  result.content = await processContent(
+    defaultedData.content,
+    toComponent(result.root)
+  );
+  result.zones = resolvedZones;
+  return result;
+}
+
+// lib/field-transforms/default-transforms/slot-transform.tsx
+init_react_import();
+var getSlotTransform = (renderSlotEdit, renderSlotRender = renderSlotEdit) => ({
+  slot: ({ value: content, propName, field, isReadOnly }) => {
+    const render = isReadOnly ? renderSlotRender : renderSlotEdit;
+    const Slot = (dzProps) => render({
+      allow: field?.type === "slot" ? field.allow : [],
+      disallow: field?.type === "slot" ? field.disallow : [],
+      ...dzProps,
+      zone: propName,
+      content
+    });
+    return Slot;
+  }
+});
+
+// lib/use-slots.tsx
+init_react_import();
+
+// lib/field-transforms/use-field-transforms.tsx
+init_react_import();
+import { useMemo } from "react";
+
+// lib/field-transforms/build-mappers.ts
+init_react_import();
+function buildMappers(transforms, readOnly, forceReadOnly) {
+  return Object.keys(transforms).reduce((acc, _fieldType) => {
+    const fieldType = _fieldType;
+    return {
+      ...acc,
+      [fieldType]: ({
+        parentId,
+        ...params
+      }) => {
+        const wildcardPath = params.propPath.replace(/\[\d+\]/g, "[*]");
+        const isReadOnly = readOnly?.[params.propPath] || readOnly?.[wildcardPath] || forceReadOnly || false;
+        const fn = transforms[fieldType];
+        return fn?.({
+          ...params,
+          isReadOnly,
+          componentId: parentId
+        });
+      }
+    };
+  }, {});
+}
+
+// lib/field-transforms/use-field-transforms.tsx
+function useFieldTransforms(config, item, transforms, readOnly, forceReadOnly) {
+  const mappers = useMemo(
+    () => buildMappers(transforms, readOnly, forceReadOnly),
+    [transforms, readOnly, forceReadOnly]
+  );
+  const transformedProps = useMemo(() => {
+    return mapFields(item, mappers, config).props;
+  }, [config, item, mappers]);
+  const mergedProps = useMemo(
+    () => ({ ...item.props, ...transformedProps }),
+    [item.props, transformedProps]
+  );
+  return mergedProps;
+}
+
+// lib/use-slots.tsx
+function useSlots(config, item, renderSlotEdit, renderSlotRender = renderSlotEdit, readOnly, forceReadOnly) {
+  return useFieldTransforms(
+    config,
+    item,
+    getSlotTransform(renderSlotEdit, renderSlotRender),
+    readOnly,
+    forceReadOnly
+  );
+}
+
+// components/RichTextEditor/lib/use-richtext-props.tsx
+init_react_import();
+import { lazy, Suspense, useMemo as useMemo2 } from "react";
+
+// components/RichTextEditor/components/RenderFallback.tsx
+init_react_import();
+import { jsx } from "react/jsx-runtime";
+var getClassName = get_class_name_factory_default("RichTextEditor", styles_module_default);
+function RichTextRenderFallback({ content }) {
+  return /* @__PURE__ */ jsx("div", { className: getClassName(), children: /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: "rich-text",
+      dangerouslySetInnerHTML: { __html: content }
+    }
+  ) });
+}
+
+// components/RichTextEditor/lib/mapDeep.ts
+init_react_import();
+var mapDeep = (source, path, render) => {
+  if (!source) {
+    return null;
+  }
+  if (path.length === 0) {
+    return render(source);
+  }
+  const [key, ...rest] = path;
+  if (Array.isArray(source)) {
+    return source.map((item) => mapDeep(item, path, render));
+  }
+  return {
+    ...source,
+    [key]: mapDeep(source[key], rest, render)
+  };
+};
+
+// components/RichTextEditor/lib/use-richtext-props.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+var findAllRichtextKeys = (fields, path = []) => {
+  if (!fields) return [];
+  const result = [];
+  for (const [key, field] of Object.entries(fields)) {
+    const currentPath = [...path, key];
+    if (field.type === "richtext") {
+      result.push({
+        path: currentPath,
+        field
+      });
+    }
+    if (field.type === "array" && "arrayFields" in field) {
+      result.push(...findAllRichtextKeys(field.arrayFields, currentPath));
+    }
+    if (field.type === "object" && "objectFields" in field) {
+      result.push(...findAllRichtextKeys(field.objectFields, currentPath));
+    }
+  }
+  return result;
+};
+function useRichtextProps(fields, props) {
+  const richtextKeys = useMemo2(() => findAllRichtextKeys(fields), [fields]);
+  const richtextProps = useMemo2(() => {
+    if (!richtextKeys?.length) return {};
+    const RichTextRender = lazy(
+      () => import("./Render-JBFI6HYN.mjs").then((m) => ({
+        default: m.RichTextRender
+      }))
+    );
+    let result = { ...props };
+    for (const { path, field } of richtextKeys) {
+      result = mapDeep(result, path, (content) => /* @__PURE__ */ jsx2(
+        Suspense,
+        {
+          fallback: /* @__PURE__ */ jsx2(RichTextRenderFallback, { content }),
+          children: /* @__PURE__ */ jsx2(RichTextRender, { content, field })
+        },
+        generateId()
+      ));
+    }
+    return result;
+  }, [richtextKeys, props]);
+  return richtextProps;
+}
+
+// components/SlotRender/server.tsx
+init_react_import();
+import { forwardRef } from "react";
+import { jsx as jsx3 } from "react/jsx-runtime";
+var SlotRenderPure = (props) => /* @__PURE__ */ jsx3(SlotRender, { ...props });
+var Item = ({
+  config,
+  item,
+  metadata
+}) => {
+  const Component = config.components[item.type];
+  const props = useSlots(config, item, (slotProps) => /* @__PURE__ */ jsx3(SlotRenderPure, { ...slotProps, config, metadata }));
+  const richtextProps = useRichtextProps(Component.fields, props);
+  return /* @__PURE__ */ jsx3(
+    Component.render,
+    {
+      ...props,
+      ...richtextProps,
+      credbuild: {
+        ...props.credbuild,
+        metadata: metadata || {}
+      }
+    }
+  );
+};
+var SlotRender = forwardRef(
+  function SlotRenderInternal({ className, style, content, config, metadata, as }, ref) {
+    const El = as ?? "div";
+    return /* @__PURE__ */ jsx3(El, { className, style, ref, children: content.map((item) => {
+      if (!config.components[item.type]) {
+        return null;
+      }
+      return /* @__PURE__ */ jsx3(
+        Item,
+        {
+          config,
+          item,
+          metadata
+        },
+        item.props.id
+      );
+    }) });
+  }
+);
+
+export {
+  buildMappers,
+  getSlotTransform,
+  useSlots,
+  RichTextRenderFallback,
+  useRichtextProps,
+  SlotRenderPure,
+  SlotRender,
+  migrate,
+  transformProps,
+  resolveAllData
+};

package/dist/chunk-B4BOBGYB.mjs

@@ -0,0 +1,42 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// react-import.js
+import React from "react";
+var init_react_import = __esm({
+  "react-import.js"() {
+    "use strict";
+  }
+});
+
+export {
+  __commonJS,
+  __toESM,
+  init_react_import
+};

package/dist/chunk-CDMESQDA.mjs

@@ -0,0 +1,148 @@
+import {
+  mapFields,
+  toComponent
+} from "./chunk-GUJDGRSM.mjs";
+import {
+  init_react_import
+} from "./chunk-B4BOBGYB.mjs";
+
+// components/ViewportControls/default-viewports.ts
+init_react_import();
+var defaultViewports = [
+  { width: 360, height: "auto", icon: "Smartphone", label: "Small" },
+  { width: 768, height: "auto", icon: "Tablet", label: "Medium" },
+  { width: 1280, height: "auto", icon: "Monitor", label: "Large" },
+  { width: "100%", height: "auto", icon: "FullWidth", label: "Full-width" }
+];
+
+// lib/resolve-component-data.ts
+init_react_import();
+
+// lib/get-changed.ts
+init_react_import();
+import { deepEqual } from "fast-equals";
+var getChanged = (newItem, oldItem) => {
+  return newItem ? Object.keys(newItem.props || {}).reduce((acc, item) => {
+    const newItemProps = newItem?.props || {};
+    const oldItemProps = oldItem?.props || {};
+    return {
+      ...acc,
+      [item]: !deepEqual(oldItemProps[item], newItemProps[item])
+    };
+  }, {}) : {};
+};
+
+// lib/resolve-component-data.ts
+import { deepEqual as deepEqual2 } from "fast-equals";
+var cache = { lastChange: {} };
+var resolveComponentData = async (item, config, metadata = {}, onResolveStart, onResolveEnd, trigger = "replace", parent = null) => {
+  const configForItem = "type" in item && item.type !== "root" ? config.components[item.type] : config.root;
+  const resolvedItem = {
+    ...item
+  };
+  const shouldRunResolver = configForItem?.resolveData && item.props;
+  const id = "id" in item.props ? item.props.id : "root";
+  if (shouldRunResolver) {
+    const {
+      item: oldItem = null,
+      resolved = {},
+      parentId: oldParentId = null
+    } = cache.lastChange[id] || {};
+    const isRootOrInserted = oldParentId === null;
+    const parentChanged = !isRootOrInserted && parent?.props.id !== oldParentId;
+    const dataChanged = item && !deepEqual2(item, oldItem);
+    const shouldSkip = trigger === "move" && !parentChanged || trigger !== "move" && trigger !== "force" && !dataChanged;
+    if (shouldSkip) {
+      return { node: resolved, didChange: false };
+    }
+    const changed = getChanged(item, oldItem);
+    if (onResolveStart) {
+      onResolveStart(item);
+    }
+    const { props: resolvedProps, readOnly = {} } = await configForItem.resolveData(item, {
+      changed,
+      lastData: oldItem,
+      metadata: { ...metadata, ...configForItem.metadata },
+      trigger,
+      parent
+    });
+    resolvedItem.props = {
+      ...item.props,
+      ...resolvedProps
+    };
+    if (Object.keys(readOnly).length) {
+      resolvedItem.readOnly = readOnly;
+    }
+  }
+  const itemAsComponentData = toComponent(resolvedItem);
+  let itemWithResolvedChildren = await mapFields(
+    resolvedItem,
+    {
+      slot: async ({ value }) => {
+        const content = value;
+        return await Promise.all(
+          content.map(
+            async (childItem) => (await resolveComponentData(
+              childItem,
+              config,
+              metadata,
+              onResolveStart,
+              onResolveEnd,
+              trigger,
+              itemAsComponentData
+            )).node
+          )
+        );
+      }
+    },
+    config
+  );
+  if (shouldRunResolver && onResolveEnd) {
+    onResolveEnd(resolvedItem);
+  }
+  cache.lastChange[id] = {
+    item,
+    resolved: itemWithResolvedChildren,
+    parentId: parent?.props.id
+  };
+  return {
+    node: itemWithResolvedChildren,
+    didChange: !deepEqual2(item, itemWithResolvedChildren)
+  };
+};
+
+// store/default-app-state.ts
+init_react_import();
+var defaultAppState = {
+  data: { content: [], root: {}, zones: {} },
+  ui: {
+    leftSideBarVisible: true,
+    rightSideBarVisible: true,
+    arrayState: {},
+    itemSelector: null,
+    componentList: {},
+    isDragging: false,
+    previewMode: "edit",
+    viewports: {
+      current: {
+        width: defaultViewports[0].width,
+        height: defaultViewports[0].height || "auto"
+      },
+      options: [],
+      controlsVisible: true
+    },
+    field: { focus: null },
+    plugin: { current: null }
+  },
+  indexes: {
+    nodes: {},
+    zones: {}
+  }
+};
+
+export {
+  defaultViewports,
+  getChanged,
+  resolveComponentData,
+  defaultAppState
+};