@resistdesign/voltra 3.0.0-alpha.5 → 3.0.0-alpha.51

package/chunk-ATO2455Q.js

@@ -0,0 +1,258 @@
+import YAML from 'yaml';
+
+// src/iac/utils/patch-utils.ts
+var DEFAULT_MERGE_STRATEGY = "transpose";
+var getValuePathString = (valuePathArray = []) => valuePathArray.map((p) => encodeURIComponent(p)).join("/");
+var getValuePathArray = (valuePathString = "") => valuePathString.split("/").map((p) => decodeURIComponent(p));
+var isConstructedFrom = (value, constructorReference) => value !== null && typeof value === "object" && "constructor" in value && value.constructor === constructorReference;
+var mergeValues = (valuePathArray = [], existingValue, newValue, mergeStrategyMap = {}) => {
+  const valuePathString = getValuePathString(valuePathArray);
+  const arrayIndexWildcardValuePathString = getValuePathString(
+    valuePathArray.map((p) => typeof p === "number" ? "#" : p)
+  );
+  const {
+    [valuePathString]: {
+      strategy: specificKeyMergeStrategy = DEFAULT_MERGE_STRATEGY,
+      data: specificKeyMergeStrategyData = void 0
+    } = {},
+    [arrayIndexWildcardValuePathString]: {
+      strategy: arrayIndexWildcardMergeStrategy = DEFAULT_MERGE_STRATEGY,
+      data: arrayIndexWildcardMergeStrategyData = void 0
+    } = {}
+  } = mergeStrategyMap;
+  const mergeStrategy = valuePathString in mergeStrategyMap ? specificKeyMergeStrategy : arrayIndexWildcardMergeStrategy;
+  const mergeStrategyData = valuePathString in mergeStrategyMap ? specificKeyMergeStrategyData : arrayIndexWildcardMergeStrategyData;
+  let mergedValue = typeof newValue !== "undefined" ? newValue : existingValue;
+  if (mergeStrategy !== "replace") {
+    if (isConstructedFrom(existingValue, Array) && isConstructedFrom(newValue, Array)) {
+      if (mergeStrategy === "accumulate") {
+        mergedValue = [...existingValue, ...newValue];
+      } else if (mergeStrategy === "accumulate-unique") {
+        mergedValue = [
+          ...existingValue,
+          ...newValue.filter((item) => existingValue.indexOf(item) === -1)
+        ];
+      } else if (mergeStrategy === "accumulate-unique-by") {
+        const existingItemMap = {};
+        const newItemMap = {};
+        for (let i = 0; i < existingValue.length; i++) {
+          const existingItem = existingValue[i];
+          if (existingItem && typeof existingItem === "object") {
+            const identifier = mergeStrategyData instanceof Function ? mergeStrategyData(existingItem) : existingItem[mergeStrategyData];
+            existingItemMap[identifier] = existingItem;
+          }
+        }
+        for (let j = 0; j < newValue.length; j++) {
+          const newItem = newValue[j];
+          if (newItem && typeof newItem === "object") {
+            const identifier = mergeStrategyData instanceof Function ? mergeStrategyData(newItem) : newItem[mergeStrategyData];
+            newItemMap[identifier] = newItem;
+          }
+        }
+        mergedValue = Object.keys({
+          ...existingItemMap,
+          ...newItemMap
+        }).map(
+          (id, index) => mergeValues(
+            [...valuePathArray, index],
+            existingItemMap[id],
+            newItemMap[id],
+            mergeStrategyMap
+          )
+        );
+      } else if (mergeStrategy === "transpose") {
+        const fullLength = Math.max(existingValue.length, newValue.length);
+        mergedValue = [...new Array(fullLength)].map(
+          (_empty, index) => mergeValues(
+            [...valuePathArray, index],
+            existingValue[index],
+            newValue[index],
+            mergeStrategyMap
+          )
+        );
+      }
+    } else if (isConstructedFrom(existingValue, Object) && isConstructedFrom(newValue, Object)) {
+      mergedValue = Object.keys({ ...existingValue, ...newValue }).reduce(
+        (acc, k) => ({
+          ...acc,
+          [k]: mergeValues(
+            [...valuePathArray, k],
+            existingValue[k],
+            newValue[k],
+            mergeStrategyMap
+          )
+        }),
+        {}
+      );
+    }
+  }
+  return mergedValue;
+};
+
+// src/iac/utils/index.ts
+var addParameter = (parameterInfo, template) => {
+  const { ParameterId, Parameter, Label, Group } = parameterInfo;
+  const {
+    Parameters,
+    Metadata: {
+      "AWS::CloudFormation::Interface": {
+        ParameterGroups = [],
+        ParameterLabels = {}
+      } = {}
+    } = {}
+  } = template;
+  let NewParameterGroups = ParameterGroups;
+  if (Group) {
+    const GroupObject = ParameterGroups.filter(
+      (g) => g.Label?.default === Group
+    )[0];
+    NewParameterGroups = GroupObject ? ParameterGroups.map(
+      (g) => g.Label?.default === Group ? {
+        ...g,
+        Parameters: [...g.Parameters || [], ParameterId]
+      } : g
+    ) : [
+      ...ParameterGroups,
+      {
+        Label: {
+          default: Group
+        },
+        Parameters: [ParameterId]
+      }
+    ];
+  }
+  return {
+    ...template,
+    Parameters: {
+      ...Parameters,
+      [ParameterId]: Parameter
+    },
+    Metadata: {
+      ...template.Metadata,
+      "AWS::CloudFormation::Interface": {
+        ...template?.Metadata?.["AWS::CloudFormation::Interface"],
+        ParameterGroups: NewParameterGroups,
+        ParameterLabels: {
+          ...ParameterLabels,
+          [ParameterId]: {
+            default: Label
+          }
+        }
+      }
+    }
+  };
+};
+var addParameters = (parameters, template) => parameters.reduce((acc, p) => addParameter(p, acc), template);
+var patchTemplate = (patch, template) => mergeValues([], template, patch, {
+  [getValuePathString([
+    // Parameter Groups
+    "Metadata",
+    "AWS::CloudFormation::Interface",
+    "ParameterGroups"
+  ])]: {
+    strategy: "accumulate-unique-by",
+    data: (pG) => pG?.Label?.default
+  },
+  [getValuePathString([
+    // Parameter Group Parameter Ids
+    "Metadata",
+    "AWS::CloudFormation::Interface",
+    "ParameterGroups",
+    "#",
+    "Parameters"
+  ])]: {
+    strategy: "accumulate-unique"
+  }
+});
+var createResourcePack = (creator) => (params, template) => {
+  const patch = creator(params);
+  return patchTemplate(patch, template);
+};
+var SimpleCFT = class {
+  /**
+   * Create a SimpleCFT template wrapper.
+   *
+   * @param template - Initial CloudFormation template.
+   */
+  constructor(template = {
+    AWSTemplateFormatVersion: "2010-09-09"
+  }) {
+    this.template = template;
+  }
+  /**
+   * Apply a pack with configuration to the stack template.
+   * @see `@resistdesign/voltra/iac` and `@resistdesign/voltra/iac/packs` for examples.
+   * */
+  applyPack = (pack, params) => {
+    this.template = pack(params, this.template);
+    return this;
+  };
+  /**
+   * Apply a patch to the stack template.
+   *
+   * @param patch - Template patch to merge.
+   * */
+  patch = (patch) => {
+    this.template = patchTemplate(patch, this.template);
+    return this;
+  };
+  /**
+   * Add a stack parameter including its descriptive info and an optional parameter group.
+   *
+   * @param parameter - Parameter definition and metadata.
+   * */
+  addParameter = (parameter) => {
+    this.template = addParameter(parameter, this.template);
+    return this;
+  };
+  /**
+   * Add a group of stack parameters including their descriptive info and an optional parameter group.
+   *
+   * @param group - Parameter group definition.
+   * */
+  addParameterGroup = ({ Label: Group, Parameters }) => {
+    const parameterIds = Object.keys(Parameters);
+    const parameterList = parameterIds.map((ParameterId) => {
+      const { Label, ...Parameter } = Parameters[ParameterId];
+      return {
+        Group,
+        ParameterId,
+        Label,
+        Parameter
+      };
+    });
+    this.template = addParameters(parameterList, this.template);
+    return this;
+  };
+  /**
+   * Use a modification to dynamically apply various changes at once.
+   *
+   * @param modification - Modification callback to apply.
+   * */
+  modify = (modification) => {
+    modification(this);
+    return this;
+  };
+  /**
+   * Convert the stack template to a string.
+   *
+   * @returns JSON string representation of the template.
+   * */
+  toString = () => JSON.stringify(this.template, null, 2);
+  /**
+   * Convert the stack template to a JSON object.
+   *
+   * @returns Template JSON object.
+   * */
+  toJSON = () => this.template;
+  /**
+   * Convert the stack template to a YAML string.
+   *
+   * @returns YAML string representation of the template.
+   * */
+  toYAML = () => YAML.stringify(this.template, {
+    aliasDuplicateObjects: false
+  });
+};
+
+export { DEFAULT_MERGE_STRATEGY, SimpleCFT, addParameter, addParameters, createResourcePack, getValuePathArray, getValuePathString, isConstructedFrom, mergeValues, patchTemplate };

package/chunk-BSHQIRBV.js

@@ -0,0 +1,71 @@
+import { parseTemplate, validateAreas } from './chunk-K4R2PFNG.js';
+
+// src/app/utils/EasyLayout.tsx
+var getPascalCaseAreaName = (area) => {
+  return area.split("-").map((a) => a[0].toUpperCase() + a.slice(1)).join("");
+};
+var convertLayoutToCSS = (layout = "", spacing = {}) => {
+  const parsed = parseTemplate(layout);
+  validateAreas(parsed);
+  const renderTrack = (track) => {
+    if (track.kind === "px") {
+      return `${track.value}px`;
+    }
+    if (track.kind === "pct") {
+      return `${track.value}%`;
+    }
+    return `${track.value}fr`;
+  };
+  const areaRows = parsed.areaGrid.map((row) => row.join(" "));
+  const rows = parsed.rowTracks.map(renderTrack);
+  let css = "";
+  if (parsed.colTracks.length) {
+    css += `
+grid-template-columns: ${parsed.colTracks.map(renderTrack).join(" ")};`;
+  }
+  css += `
+grid-template-areas:
+${areaRows.map((a) => `  "${a}"`).join("\n")};`;
+  if (rows.length) {
+    css += `
+grid-template-rows: ${rows.join(" ")};`;
+  }
+  if (typeof spacing.gap !== "undefined") {
+    css += `
+gap: ${typeof spacing.gap === "number" ? `${spacing.gap}px` : spacing.gap};`;
+  }
+  if (typeof spacing.padding !== "undefined") {
+    css += `
+padding: ${typeof spacing.padding === "number" ? `${spacing.padding}px` : spacing.padding};`;
+  }
+  return {
+    areasList: parsed.areaNames,
+    css
+  };
+};
+var getEasyLayoutTemplateDetails = (layout = "", spacing = {}) => convertLayoutToCSS(layout, spacing);
+var createEasyLayout = (config, extendFrom, areasExtendFrom, spacing = {}) => {
+  return (layoutTemplate, ...expressions) => {
+    const mergedTemplate = layoutTemplate.reduce((acc, l, ind) => {
+      const expr = expressions[ind - 1];
+      const exprStr = typeof expr === "undefined" ? "" : expr;
+      return `${acc}${l}${exprStr}`;
+    }, "");
+    const { areasList, css } = convertLayoutToCSS(mergedTemplate, spacing);
+    const layout = config.createLayout({ base: extendFrom, css });
+    const areas = areasList.reduce((acc, area) => {
+      const pascalCaseAreaName = getPascalCaseAreaName(area);
+      const component = config.createArea({ base: areasExtendFrom, area });
+      return {
+        ...acc,
+        [pascalCaseAreaName]: component
+      };
+    }, {});
+    return {
+      layout,
+      areas
+    };
+  };
+};
+
+export { createEasyLayout, getEasyLayoutTemplateDetails, getPascalCaseAreaName };

package/chunk-I2KLQ2HA.js

@@ -0,0 +1,19 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+
+export { __export, __reExport };