@oberoncms/core/dist/adapter/transforms.js

OberonCMS is a cloud deployable CMS written in typescript based on the Puck visual editor

async function transformProps(data, propTransforms) {
  const mapItem = async (item) => {
    var _a;
    if (propTransforms[item.type]) {
      return {
        ...item,
        props: await ((_a = propTransforms[item.type]) == null ? void 0 : _a.call(propTransforms, item.props))
      };
    }
    return item;
  };
  const root = propTransforms["root"] ? propTransforms["root"](data.root) : data.root;
  const afterPropTransforms = {
    ...data,
    root,
    content: await Promise.all(data.content.map(mapItem)),
    zones: await Object.keys(data.zones || {}).reduce(async (acc, zoneKey) => {
      var _a;
      const zone = (_a = data.zones) == null ? void 0 : _a[zoneKey];
      if (!zone) {
        return acc;
      }
      return {
        ...acc,
        [zoneKey]: await Promise.all(zone.map(mapItem))
      };
    }, Promise.resolve({}))
  };
  return afterPropTransforms;
}
async function applyTransform(key, transforms, getPageData, updatePageData) {
  try {
    const data = await getPageData(key);
    if (!data) {
      return {
        type: "transform",
        key,
        status: "success"
      };
    }
    await updatePageData({
      key,
      data: await transformProps(data, transforms),
      updatedAt: /* @__PURE__ */ new Date(),
      updatedBy: "migration"
    });
    return {
      type: "transform",
      key,
      status: "success"
    };
  } catch (error) {
    console.error(error);
    return {
      type: "transform",
      key,
      status: "error"
    };
  }
}
async function* applyTransforms({
  transforms,
  pages,
  getPageData,
  updatePageData
}) {
  const migrations = [];
  for (const { key } of pages) {
    const result = applyTransform(key, transforms, getPageData, updatePageData);
    migrations.push(result);
  }
  for await (const result of migrations) {
    yield result;
  }
}
function getComponentTransformVersions({ components }) {
  var _a;
  const versions = {};
  for (const key in components) {
    const transforms = ((_a = components[key]) == null ? void 0 : _a.transforms) || [];
    versions[key] = transforms.length;
  }
  return versions;
}
function getTransforms(currentTransformVersions = {}, { components }) {
  var _a;
  const componentTransforms = {};
  const transformVersions = {};
  for (const componentKey in components) {
    const transforms = ((_a = components[componentKey]) == null ? void 0 : _a.transforms) || [];
    const latestTransform = transforms.length;
    const previousTransform = currentTransformVersions[componentKey] ?? latestTransform;
    if (previousTransform < latestTransform) {
      componentTransforms[componentKey] = (props) => transforms.slice(previousTransform).reduce((accumulater, transform) => transform(accumulater), props);
    }
    transformVersions[componentKey] = latestTransform;
  }
  const hasTransforms = !!Object.keys(componentTransforms).length;
  return {
    components: transformVersions,
    transforms: hasTransforms && componentTransforms
  };
}
export {
  applyTransforms,
  getComponentTransformVersions,
  getTransforms,
  transformProps
};