@crediblemark/build 0.25.7 → 0.25.8

package/dist/chunk-7LXZOPYT.mjs

@@ -1,445 +0,0 @@
-// lib/data/default-slots.ts
-var defaultSlots = (value, fields) => Object.keys(fields).reduce(
-  (acc, fieldName) => fields[fieldName].type === "slot" ? { [fieldName]: [], ...acc } : acc,
-  value
-);
-
-// lib/data/map-fields.ts
-var isPromise = (v) => !!v && typeof v.then === "function";
-var flatten = (values) => values.reduce((acc, item) => ({ ...acc, ...item }), {});
-var containsPromise = (arr) => arr.some(isPromise);
-var walkField = ({
-  value,
-  fields,
-  mappers,
-  propKey = "",
-  propPath = "",
-  id = "",
-  config,
-  recurseSlots = false
-}) => {
-  const fieldType = fields[propKey]?.type;
-  const map = mappers[fieldType];
-  if (map && fieldType === "slot") {
-    const content = value || [];
-    const mappedContent = recurseSlots ? content.map((el) => {
-      const componentConfig = config.components[el.type];
-      if (!componentConfig) {
-        throw new Error(`Could not find component config for ${el.type}`);
-      }
-      const fields2 = componentConfig.fields ?? {};
-      return walkField({
-        value: { ...el, props: defaultSlots(el.props, fields2) },
-        fields: fields2,
-        mappers,
-        id: el.props.id,
-        config,
-        recurseSlots
-      });
-    }) : content;
-    if (containsPromise(mappedContent)) {
-      return Promise.all(mappedContent);
-    }
-    return map({
-      value: mappedContent,
-      parentId: id,
-      propName: propPath,
-      field: fields[propKey],
-      propPath
-    });
-  } else if (map && fields[propKey]) {
-    return map({
-      value,
-      parentId: id,
-      propName: propKey,
-      field: fields[propKey],
-      propPath
-    });
-  }
-  if (value && typeof value === "object") {
-    if (Array.isArray(value)) {
-      const arrayFields = fields[propKey]?.type === "array" ? fields[propKey].arrayFields : null;
-      if (!arrayFields) return value;
-      const newValue = value.map(
-        (el, idx) => walkField({
-          value: el,
-          fields: arrayFields,
-          mappers,
-          propKey,
-          propPath: `${propPath}[${idx}]`,
-          id,
-          config,
-          recurseSlots
-        })
-      );
-      if (containsPromise(newValue)) {
-        return Promise.all(newValue);
-      }
-      return newValue;
-    } else if ("$$typeof" in value) {
-      return value;
-    } else {
-      const objectFields = fields[propKey]?.type === "object" ? fields[propKey].objectFields : fields;
-      return walkObject({
-        value,
-        fields: objectFields,
-        mappers,
-        id,
-        getPropPath: (k) => `${propPath}.${k}`,
-        config,
-        recurseSlots
-      });
-    }
-  }
-  return value;
-};
-var walkObject = ({
-  value,
-  fields,
-  mappers,
-  id,
-  getPropPath,
-  config,
-  recurseSlots
-}) => {
-  const newProps = Object.entries(value).map(([k, v]) => {
-    const opts = {
-      value: v,
-      fields,
-      mappers,
-      propKey: k,
-      propPath: getPropPath(k),
-      id,
-      config,
-      recurseSlots
-    };
-    const newValue = walkField(opts);
-    if (isPromise(newValue)) {
-      return newValue.then((resolvedValue) => ({
-        [k]: resolvedValue
-      }));
-    }
-    return {
-      [k]: newValue
-    };
-  }, {});
-  if (containsPromise(newProps)) {
-    return Promise.all(newProps).then(flatten);
-  }
-  return flatten(newProps);
-};
-function mapFields(item, mappers, config, recurseSlots = false, shouldDefaultSlots = true) {
-  const itemType = "type" in item ? item.type : "root";
-  const componentConfig = itemType === "root" ? config.root : config.components?.[itemType];
-  const newProps = walkObject({
-    value: shouldDefaultSlots ? defaultSlots(item.props ?? {}, componentConfig?.fields ?? {}) : item.props,
-    fields: componentConfig?.fields ?? {},
-    mappers,
-    id: item.props ? item.props.id ?? "root" : "root",
-    getPropPath: (k) => k,
-    config,
-    recurseSlots
-  });
-  if (isPromise(newProps)) {
-    return newProps.then((resolvedProps) => ({
-      ...item,
-      props: resolvedProps
-    }));
-  }
-  return {
-    ...item,
-    props: newProps
-  };
-}
-
-// lib/data/walk-tree.ts
-function walkTree(data, config, callbackFn) {
-  const walkItem = (item) => {
-    return mapFields(
-      item,
-      {
-        slot: ({ value, parentId, propName }) => {
-          const content = value;
-          return callbackFn(content, { parentId, propName }) ?? content;
-        }
-      },
-      config,
-      true
-    );
-  };
-  if ("props" in data) {
-    return walkItem(data);
-  }
-  const _data = data;
-  const zones = _data.zones ?? {};
-  const mappedContent = _data.content.map(walkItem);
-  return {
-    root: walkItem(_data.root),
-    content: callbackFn(mappedContent, {
-      parentId: "root",
-      propName: "default-zone"
-    }) ?? mappedContent,
-    zones: Object.keys(zones).reduce(
-      (acc, zoneCompound) => ({
-        ...acc,
-        [zoneCompound]: zones[zoneCompound].map(walkItem)
-      }),
-      {}
-    )
-  };
-}
-
-// lib/generate-id.ts
-import { v4 as uuidv4 } from "uuid";
-var generateId = (type) => type ? `${type}-${uuidv4()}` : uuidv4();
-
-// lib/root-droppable-id.ts
-var rootAreaId = "root";
-var rootZone = "default-zone";
-var rootDroppableId = `${rootAreaId}:${rootZone}`;
-
-// lib/data/flatten-node.ts
-import flat from "flat";
-
-// lib/data/strip-slots.ts
-var stripSlots = (data, config) => {
-  return mapFields(data, { slot: () => null }, config);
-};
-
-// lib/data/flatten-node.ts
-var { flatten: flatten2, unflatten } = flat;
-var isPureObject = (val) => val != null && Object.prototype.toString.call(val) === "[object Object]";
-var emptyArrayStr = "__credbuild_[]";
-var emptyObjectStr = "__credbuild_{}";
-function encodeEmptyObjects(props = {}) {
-  const result = {};
-  for (const key in props) {
-    if (!Object.prototype.hasOwnProperty.call(props, key)) continue;
-    const val = props[key];
-    if (Array.isArray(val) && val.length === 0) {
-      result[key] = emptyArrayStr;
-    } else if (isPureObject(val) && Object.keys(val).length === 0) {
-      result[key] = emptyObjectStr;
-    } else {
-      result[key] = val;
-    }
-  }
-  return result;
-}
-function decodeEmptyObjects(props = {}) {
-  const result = {};
-  for (const key in props) {
-    if (!Object.prototype.hasOwnProperty.call(props, key)) continue;
-    const val = props[key];
-    if (val === emptyArrayStr) {
-      result[key] = [];
-    } else if (val === emptyObjectStr) {
-      result[key] = {};
-    } else {
-      result[key] = val;
-    }
-  }
-  return result;
-}
-var flattenNode = (node, config) => {
-  return {
-    ...node,
-    props: encodeEmptyObjects(flatten2(stripSlots(node, config).props))
-  };
-};
-var expandNode = (node) => {
-  const props = unflatten(decodeEmptyObjects(node.props));
-  return {
-    ...node,
-    props
-  };
-};
-
-// lib/data/to-component.ts
-var toComponent = (item) => {
-  return "type" in item ? item : {
-    ...item,
-    props: { ...item.props, id: "root" },
-    type: "root"
-  };
-};
-
-// lib/get-zone-id.ts
-var getZoneId = (zoneCompound) => {
-  if (!zoneCompound) {
-    return [];
-  }
-  if (zoneCompound && zoneCompound.indexOf(":") > -1) {
-    return zoneCompound.split(":");
-  }
-  return [rootDroppableId, zoneCompound];
-};
-
-// lib/data/for-related-zones.ts
-function forRelatedZones(item, data, cb, path = []) {
-  Object.entries(data.zones || {}).forEach(([zoneCompound, content]) => {
-    const [parentId] = getZoneId(zoneCompound);
-    if (parentId === item.props.id) {
-      cb(path, zoneCompound, content);
-    }
-  });
-}
-
-// lib/data/walk-app-state.ts
-function walkAppState(state, config, mapContent = (content) => content, mapNodeOrSkip = (item) => item) {
-  let newZones = {};
-  const newZoneIndex = {};
-  const newNodeIndex = {};
-  const processContent = (path, zoneCompound, content, zoneType, newId) => {
-    const [parentId] = zoneCompound.split(":");
-    const mappedContent = (mapContent(content, zoneCompound, zoneType) ?? content) || [];
-    const [_2, zone] = zoneCompound.split(":");
-    const newZoneCompound = `${newId || parentId}:${zone}`;
-    const newContent2 = mappedContent.map(
-      (zoneChild, index) => processItem(zoneChild, [...path, newZoneCompound], index)
-    );
-    newZoneIndex[newZoneCompound] = {
-      contentIds: newContent2.map((item) => item.props.id),
-      type: zoneType
-    };
-    return [newZoneCompound, newContent2];
-  };
-  const processRelatedZones = (item, newId, initialPath) => {
-    forRelatedZones(
-      item,
-      state.data,
-      (relatedPath, relatedZoneCompound, relatedContent) => {
-        const [zoneCompound, newContent2] = processContent(
-          relatedPath,
-          relatedZoneCompound,
-          relatedContent,
-          "dropzone",
-          newId
-        );
-        newZones[zoneCompound] = newContent2;
-      },
-      initialPath
-    );
-  };
-  const processItem = (item, path, index) => {
-    const mappedItem = mapNodeOrSkip(item, path, index);
-    if (!mappedItem) return item;
-    const id = mappedItem.props.id;
-    const newProps = {
-      ...mapFields(
-        mappedItem,
-        {
-          slot: ({ value, parentId: parentId2, propPath }) => {
-            const content = value;
-            const zoneCompound = `${parentId2}:${propPath}`;
-            const [_2, newContent2] = processContent(
-              path,
-              zoneCompound,
-              content,
-              "slot",
-              parentId2
-            );
-            return newContent2;
-          }
-        },
-        config
-      ).props,
-      id
-    };
-    processRelatedZones(item, id, path);
-    const newItem = { ...mappedItem, props: newProps };
-    const thisZoneCompound = path[path.length - 1];
-    const [parentId, zone] = thisZoneCompound ? thisZoneCompound.split(":") : [null, ""];
-    newNodeIndex[id] = {
-      data: newItem,
-      flatData: flattenNode(newItem, config),
-      path,
-      parentId,
-      zone
-    };
-    const finalData = { ...newItem, props: { ...newItem.props } };
-    if (newProps.id === "root") {
-      delete finalData["type"];
-      delete finalData.props["id"];
-    }
-    return finalData;
-  };
-  const zones = state.data.zones || {};
-  const [_, newContent] = processContent(
-    [],
-    rootDroppableId,
-    state.data.content,
-    "root"
-  );
-  const processedContent = newContent;
-  const zonesAlreadyProcessed = Object.keys(newZones);
-  Object.keys(zones || {}).forEach((zoneCompound) => {
-    const [parentId] = zoneCompound.split(":");
-    if (zonesAlreadyProcessed.includes(zoneCompound)) {
-      return;
-    }
-    const [_2, newContent2] = processContent(
-      [rootDroppableId],
-      zoneCompound,
-      zones[zoneCompound],
-      "dropzone",
-      parentId
-    );
-    newZones[zoneCompound] = newContent2;
-  }, newZones);
-  let rootAsComponent = toComponent({
-    props: { ...state.data.root.props ?? state.data.root }
-  });
-  if (state.data.root.readOnly) {
-    rootAsComponent.readOnly = state.data.root.readOnly;
-  }
-  const processedRoot = processItem(rootAsComponent, [], -1);
-  const root = {
-    ...state.data.root,
-    ...processedRoot
-  };
-  return {
-    ...state,
-    data: {
-      root,
-      content: processedContent,
-      zones: {
-        ...state.data.zones,
-        ...newZones
-      }
-    },
-    indexes: {
-      nodes: { ...state.indexes.nodes, ...newNodeIndex },
-      zones: { ...state.indexes.zones, ...newZoneIndex }
-    }
-  };
-}
-
-// lib/data/setup-zone.ts
-var setupZone = (data, zoneKey) => {
-  if (zoneKey === rootDroppableId) {
-    return data;
-  }
-  const newData = {
-    ...data,
-    zones: data.zones ? { ...data.zones } : {}
-  };
-  newData.zones[zoneKey] = newData.zones[zoneKey] || [];
-  return newData;
-};
-
-export {
-  generateId,
-  rootAreaId,
-  rootZone,
-  rootDroppableId,
-  getZoneId,
-  defaultSlots,
-  walkField,
-  mapFields,
-  expandNode,
-  toComponent,
-  walkAppState,
-  walkTree,
-  setupZone
-};

package/dist/chunk-SMAWAXVX.mjs

@@ -1,139 +0,0 @@
-import {
-  mapFields,
-  toComponent
-} from "./chunk-7LXZOPYT.mjs";
-
-// components/ViewportControls/default-viewports.ts
-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/get-changed.ts
-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
-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
-};