@resistdesign/voltra 0.0.0-alpha.0

package/src/iac/types/IaCTypes.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudFormationPseudoParameters = void 0;
+var CloudFormationPseudoParameters;
+(function (CloudFormationPseudoParameters) {
+    CloudFormationPseudoParameters["AWS::AccountId"] = "AWS::AccountId";
+    CloudFormationPseudoParameters["AWS::NotificationARNs"] = "AWS::NotificationARNs";
+    CloudFormationPseudoParameters["AWS::NoValue"] = "AWS::NoValue";
+    CloudFormationPseudoParameters["AWS::Partition"] = "AWS::Partition";
+    CloudFormationPseudoParameters["AWS::Region"] = "AWS::Region";
+    CloudFormationPseudoParameters["AWS::StackId"] = "AWS::StackId";
+    CloudFormationPseudoParameters["AWS::StackName"] = "AWS::StackName";
+    CloudFormationPseudoParameters["AWS::URLSuffix"] = "AWS::URLSuffix";
+})(CloudFormationPseudoParameters || (exports.CloudFormationPseudoParameters = CloudFormationPseudoParameters = {}));

package/src/iac/types/Renderers.d.ts

@@ -0,0 +1,12 @@
+import { AttributeType, IDocumentable, NamespaceStructure, PropertyDescriptor, PropertyType, ResourceType } from './Types';
+export declare const renderPrimitiveType: (primitiveType: string) => string;
+export declare const renderPropertyType: (path: string[], { PrimitiveType, Type, PrimitiveItemType, ItemType }: AttributeType) => string;
+export declare const renderPropertyName: (propertyName: string, descriptor: PropertyDescriptor | AttributeType) => string;
+export declare const renderCommentBlock: ({ UpdateType, DuplicatesAllowed, Documentation }: IDocumentable) => string;
+export declare const renderProperty: (path: string[], propertyName: string, propertyDescriptor: PropertyDescriptor | AttributeType) => string;
+export declare const renderTypeWithFullBody: (commentBlock: string, typeName: string, fullBody: string) => string;
+export declare const renderTypePropertiesBody: (path: string[], properties: Record<string, PropertyDescriptor | AttributeType>) => string;
+export declare const renderTypeWithProperties: (path: string[], typeName: string, properties: Record<string, AttributeType>, commentBlock?: string) => string;
+export declare const renderTypeFromPropertyType: (path: string[], typeName: string, propertyType: PropertyType) => string;
+export declare const renderTypeFromResourceType: (path: string[], typeName: string, resourceType: ResourceType) => string;
+export declare const renderNamespaceStructure: ({ path, includes, propertyTypes, resourceTypes, namespaces }: NamespaceStructure, namespaceName?: string) => string;

package/src/iac/types/Renderers.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderNamespaceStructure = exports.renderTypeFromResourceType = exports.renderTypeFromPropertyType = exports.renderTypeWithProperties = exports.renderTypePropertiesBody = exports.renderTypeWithFullBody = exports.renderProperty = exports.renderCommentBlock = exports.renderPropertyName = exports.renderPropertyType = exports.renderPrimitiveType = void 0;
+const Constants_1 = require("./Constants");
+const renderPrimitiveType = (primitiveType) => primitiveType in Constants_1.PRIMITIVE_TYPE_MAP ? `CloudFormationPrimitiveValue<${Constants_1.PRIMITIVE_TYPE_MAP[primitiveType]}>` : primitiveType;
+exports.renderPrimitiveType = renderPrimitiveType;
+const renderPropertyType = (path, { PrimitiveType, Type, PrimitiveItemType, ItemType }) => {
+    if (PrimitiveType) {
+        return (0, exports.renderPrimitiveType)(PrimitiveType);
+    }
+    else if (Type && Constants_1.CONTAINER_TYPES.indexOf(Type) !== -1) {
+        const resolvedItemType = PrimitiveItemType
+            ? (0, exports.renderPrimitiveType)(PrimitiveItemType)
+            : ItemType === Constants_1.TAG_TYPE
+                ? Constants_1.TAG_TYPE
+                : [...path, ItemType].join(Constants_1.NAMESPACE_DELIMITERS.OUTPUT);
+        return Type === 'List' ? `${resolvedItemType}[]` : `Record<string, ${resolvedItemType}>`;
+    }
+    else if (Type === Constants_1.TAG_TYPE) {
+        return Constants_1.TAG_TYPE;
+    }
+    else if (Type) {
+        return [...path, Type].join(Constants_1.NAMESPACE_DELIMITERS.OUTPUT);
+    }
+    else {
+        return Constants_1.NEVER_TYPE;
+    }
+};
+exports.renderPropertyType = renderPropertyType;
+const renderPropertyName = (propertyName, descriptor) => {
+    const cleanPropertyName = propertyName && propertyName.indexOf('.') !== -1 ? `'${propertyName}'` : propertyName;
+    if ('Required' in descriptor) {
+        const { Required } = descriptor;
+        return `${cleanPropertyName}${Required ? '' : '?'}`;
+    }
+    else {
+        return cleanPropertyName;
+    }
+};
+exports.renderPropertyName = renderPropertyName;
+const renderCommentBlock = ({ UpdateType, DuplicatesAllowed = false, Documentation }) => UpdateType || DuplicatesAllowed || Documentation
+    ? `/**${UpdateType
+        ? `
+ * Update Type: ${UpdateType}`
+        : ''}${DuplicatesAllowed
+        ? `
+ * Duplicates Allowed: Yes`
+        : ''}${Documentation
+        ? `
+ * @see ${Documentation}`
+        : ''}
+ * */
+`
+    : '';
+exports.renderCommentBlock = renderCommentBlock;
+const renderProperty = (path, propertyName, propertyDescriptor) => `${(0, exports.renderCommentBlock)(propertyDescriptor)}${(0, exports.renderPropertyName)(propertyName, propertyDescriptor)}: ${(0, exports.renderPropertyType)(path, propertyDescriptor)};`;
+exports.renderProperty = renderProperty;
+const renderTypeWithFullBody = (commentBlock, typeName, fullBody) => `${commentBlock}export type ${typeName} = ${fullBody};`;
+exports.renderTypeWithFullBody = renderTypeWithFullBody;
+const renderTypePropertiesBody = (path, properties) => {
+    const propertyKeys = Object.keys(properties);
+    return `{
+${propertyKeys.map((pK) => (0, exports.renderProperty)(path, pK, properties[pK])).join('\n')}
+}`;
+};
+exports.renderTypePropertiesBody = renderTypePropertiesBody;
+const renderTypeWithProperties = (path, typeName, properties, commentBlock = '') => {
+    return (0, exports.renderTypeWithFullBody)(commentBlock, typeName, (0, exports.renderTypePropertiesBody)(path, properties));
+};
+exports.renderTypeWithProperties = renderTypeWithProperties;
+const renderTypeFromPropertyType = (path, typeName, propertyType) => {
+    const { Properties } = propertyType;
+    const commentBlock = (0, exports.renderCommentBlock)(propertyType);
+    if (Properties) {
+        return (0, exports.renderTypeWithProperties)(path, typeName, Properties, commentBlock);
+    }
+    else {
+        return `${commentBlock}export type ${typeName} = ${(0, exports.renderPropertyType)(path, propertyType)}`;
+    }
+};
+exports.renderTypeFromPropertyType = renderTypeFromPropertyType;
+const renderTypeFromResourceType = (path, typeName, resourceType) => {
+    const { Type, Properties, Attributes } = resourceType;
+    const commentBlock = (0, exports.renderCommentBlock)(resourceType);
+    const subPath = [...path, typeName];
+    return (0, exports.renderTypeWithFullBody)(commentBlock, typeName, `CloudFormationResource<'${Type}', ${Attributes ? (0, exports.renderTypePropertiesBody)(subPath, Attributes) : Constants_1.NEVER_TYPE}, ${Properties ? (0, exports.renderTypePropertiesBody)(subPath, Properties) : Constants_1.NEVER_TYPE}>`);
+};
+exports.renderTypeFromResourceType = renderTypeFromResourceType;
+const renderNamespaceStructure = ({ path = [], includes = [], propertyTypes = {}, resourceTypes = {}, namespaces = {} }, namespaceName) => {
+    const namespaceBody = `${includes?.join('\n')}
+
+${Object.keys(propertyTypes)
+        .map((pT) => (0, exports.renderTypeFromPropertyType)(path, pT, propertyTypes[pT]))
+        .join('\n')}
+
+${Object.keys(resourceTypes)
+        .map((rT) => (0, exports.renderTypeFromResourceType)(path, rT, resourceTypes[rT]))
+        .join('\n')}
+
+${Object.keys(namespaces)
+        .map((ns) => (0, exports.renderNamespaceStructure)(namespaces[ns], ns))
+        .join('\n')}`;
+    if (namespaceName) {
+        return `export namespace ${namespaceName} {
+${namespaceBody}
+}`;
+    }
+    else {
+        return namespaceBody;
+    }
+};
+exports.renderNamespaceStructure = renderNamespaceStructure;

package/src/iac/types/Types.d.ts

@@ -0,0 +1,37 @@
+export interface IDocumentable {
+    UpdateType?: string;
+    DuplicatesAllowed?: boolean;
+    Documentation?: string;
+}
+export type AttributeType = {
+    PrimitiveType?: string;
+    Type?: string;
+    ItemType?: string;
+    PrimitiveItemType?: string;
+    DuplicatesAllowed?: boolean;
+};
+export type PropertyDescriptor = IDocumentable & AttributeType & {
+    Required?: boolean;
+};
+export type PropertyType = PropertyDescriptor & {
+    Properties?: Record<string, PropertyDescriptor>;
+};
+export type ResourceType = {
+    Type?: string;
+    Documentation?: string;
+    AdditionalProperties?: boolean;
+    Properties?: Record<string, PropertyDescriptor>;
+    Attributes?: Record<string, AttributeType>;
+};
+export type CloudFormationResourceSpecification = {
+    PropertyTypes: Record<string, PropertyType>;
+    ResourceTypes: Record<string, ResourceType>;
+    ResourceSpecificationVersion: `${number}.${number}.${number}`;
+};
+export type NamespaceStructure = {
+    path: string[];
+    includes?: string[];
+    propertyTypes?: Record<string, PropertyType>;
+    resourceTypes?: Record<string, ResourceType>;
+    namespaces?: Record<string, NamespaceStructure>;
+};

package/src/iac/types/Types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/iac/types/Utils.d.ts

@@ -0,0 +1,2 @@
+import { CloudFormationResourceSpecification, NamespaceStructure } from './Types';
+export declare const getNamespaceStructure: (specification: CloudFormationResourceSpecification, baseStructure: NamespaceStructure) => NamespaceStructure;

package/src/iac/types/Utils.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNamespaceStructure = void 0;
+const Constants_1 = require("./Constants");
+const getNamespaceStructure = (specification, baseStructure) => {
+    const newStructure = {
+        ...baseStructure,
+    };
+    const { PropertyTypes, ResourceTypes } = specification;
+    const propertyTypesKeys = Object.keys(PropertyTypes);
+    const resourceTypesKeys = Object.keys(ResourceTypes);
+    const resourceTypeOptions = [];
+    for (const pTK of propertyTypesKeys) {
+        const fullPropertyTypeNameParts = pTK
+            .replace(Constants_1.NAMESPACE_DELIMITERS.INPUT_REGEX, () => Constants_1.NAMESPACE_DELIMITERS.OUTPUT)
+            .split(Constants_1.NAMESPACE_DELIMITERS.OUTPUT);
+        const propType = PropertyTypes[pTK];
+        const currentPath = [];
+        let targetNamespace = newStructure;
+        for (let i = 0; i < fullPropertyTypeNameParts.length; i++) {
+            const part = fullPropertyTypeNameParts[i];
+            currentPath.push(part);
+            if (i === fullPropertyTypeNameParts.length - 1) {
+                targetNamespace.propertyTypes = targetNamespace.propertyTypes || {};
+                targetNamespace.propertyTypes[part] = propType;
+            }
+            else {
+                targetNamespace.namespaces = targetNamespace.namespaces || {};
+                targetNamespace.namespaces[part] = targetNamespace.namespaces[part] || { path: [...currentPath] };
+                targetNamespace = targetNamespace.namespaces[part];
+            }
+        }
+    }
+    for (const rTK of resourceTypesKeys) {
+        const fullResourceTypeNameParts = rTK.split(Constants_1.NAMESPACE_DELIMITERS.INPUT);
+        const resType = ResourceTypes[rTK];
+        const currentPath = [];
+        let targetNamespace = newStructure;
+        for (let i = 0; i < fullResourceTypeNameParts.length; i++) {
+            const part = fullResourceTypeNameParts[i];
+            currentPath.push(part);
+            if (i === fullResourceTypeNameParts.length - 1) {
+                targetNamespace.resourceTypes = targetNamespace.resourceTypes || {};
+                targetNamespace.resourceTypes[part] = {
+                    ...resType,
+                    Type: rTK,
+                };
+                resourceTypeOptions.push(currentPath.join(Constants_1.NAMESPACE_DELIMITERS.OUTPUT));
+            }
+            else {
+                targetNamespace.namespaces = targetNamespace.namespaces || {};
+                targetNamespace.namespaces[part] = targetNamespace.namespaces[part] || { path: [...currentPath] };
+                targetNamespace = targetNamespace.namespaces[part];
+            }
+        }
+    }
+    newStructure.includes = [`export type AllResourceTypes = ${resourceTypeOptions.join(' | ')};`, ...(newStructure.includes || [])];
+    return newStructure;
+};
+exports.getNamespaceStructure = getNamespaceStructure;

package/src/iac/types/generate.d.ts

@@ -0,0 +1 @@
+export {};

package/src/iac/types/generate.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const prettier_1 = require("prettier");
+const CloudFormationResourceSpecification_1 = require("./CloudFormationResourceSpecification");
+const Utils_1 = require("./Utils");
+const Renderers_1 = require("./Renderers");
+const STANDARD_INCLUDES = fs_1.default.readFileSync(path_1.default.join(__dirname, "StandardIncludes.d.ts.tmpl"), { encoding: "utf8" })
+    // IMPORTANT: Remove the first line which is a placeholder for the `AllResourceTypes` type.
+    .replace(/.*/, "")
+    .trimStart();
+const BASE_NAMESPACE_STRUCTURE = {
+    path: [],
+    includes: [STANDARD_INCLUDES],
+    propertyTypes: {},
+    resourceTypes: {},
+    namespaces: {},
+};
+const NamespaceStructure = (0, Utils_1.getNamespaceStructure)(CloudFormationResourceSpecification_1.CloudFormationResourceSpecificationData, BASE_NAMESPACE_STRUCTURE);
+const generate = async () => {
+    const TypesContentString = await (0, prettier_1.format)((0, Renderers_1.renderNamespaceStructure)(NamespaceStructure), {
+        parser: "typescript",
+    });
+    fs_1.default.mkdirSync(path_1.default.join(__dirname, "..", "dist"), { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(__dirname, "..", "dist", "IaCTypes.ts"), TypesContentString, { encoding: "utf8" });
+};
+generate();

package/src/iac/utils/index.d.ts

@@ -0,0 +1,36 @@
+import { CloudFormationParameter, CloudFormationTemplate } from "../types/IaCTypes";
+export * from "./patch-utils";
+export type ParameterInfo = {
+    ParameterId: string;
+    Parameter: CloudFormationParameter;
+    Label: string;
+    Group?: string;
+};
+/**
+ * Add a stack parameter including its descriptive info and an optional parameter group.
+ * */
+export declare const addParameter: (parameterInfo: ParameterInfo, template: CloudFormationTemplate) => CloudFormationTemplate;
+/**
+ * Add multiple stack parameters with info and groups.
+ * */
+export declare const addParameters: (parameters: ParameterInfo[], template: CloudFormationTemplate) => CloudFormationTemplate;
+/**
+ * A function used to apply a pack to a stack template.
+ * */
+export type ResourcePackApplier<ParamsType> = (params: ParamsType, template: CloudFormationTemplate) => CloudFormationTemplate;
+/**
+ * Apply a patch to a stack template.
+ * */
+export declare const patchTemplate: (patch: Partial<CloudFormationTemplate>, template: CloudFormationTemplate) => CloudFormationTemplate;
+/**
+ * Create a custom resource pack that can use configuration input to patch a stack with convenient resources, parameters, etc.
+ * */
+export declare const createResourcePack: <ParamsType>(creator: (params: ParamsType) => Partial<CloudFormationTemplate>) => ResourcePackApplier<ParamsType>;
+export type ParameterGroup = {
+    Label: string;
+    Parameters: {
+        [parameterId: string]: {
+            Label: string;
+        } & CloudFormationParameter;
+    };
+};

package/src/iac/utils/index.js

@@ -0,0 +1,105 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createResourcePack = exports.patchTemplate = exports.addParameters = exports.addParameter = void 0;
+const patch_utils_1 = require("./patch-utils");
+__exportStar(require("./patch-utils"), exports);
+/**
+ * Add a stack parameter including its descriptive info and an optional parameter group.
+ * */
+const 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,
+                    },
+                },
+            },
+        },
+    };
+};
+exports.addParameter = addParameter;
+/**
+ * Add multiple stack parameters with info and groups.
+ * */
+const addParameters = (parameters, template) => parameters.reduce((acc, p) => (0, exports.addParameter)(p, acc), template);
+exports.addParameters = addParameters;
+/**
+ * Apply a patch to a stack template.
+ * */
+const patchTemplate = (patch, template) => (0, patch_utils_1.mergeValues)([], template, patch, {
+    [(0, patch_utils_1.getValuePathString)([
+        // Parameter Groups
+        "Metadata",
+        "AWS::CloudFormation::Interface",
+        "ParameterGroups",
+    ])]: {
+        strategy: "accumulate-unique-by",
+        data: (pG) => pG?.Label?.default,
+    },
+    [(0, patch_utils_1.getValuePathString)([
+        // Parameter Group Parameter Ids
+        "Metadata",
+        "AWS::CloudFormation::Interface",
+        "ParameterGroups",
+        "#",
+        "Parameters",
+    ])]: {
+        strategy: "accumulate-unique",
+    },
+});
+exports.patchTemplate = patchTemplate;
+/**
+ * Create a custom resource pack that can use configuration input to patch a stack with convenient resources, parameters, etc.
+ * */
+const createResourcePack = (creator) => (params, template) => {
+    const patch = creator(params);
+    return (0, exports.patchTemplate)(patch, template);
+};
+exports.createResourcePack = createResourcePack;

package/src/iac/utils/patch-utils.d.ts

@@ -0,0 +1,15 @@
+export type MergeStrategy = 'transpose' | 'accumulate' | 'accumulate-unique' | 'accumulate-unique-by' | 'replace';
+export type MergeStrategyDescriptor = {
+    strategy: MergeStrategy;
+} | {
+    strategy: 'accumulate-unique-by';
+    data: string | ((value: any) => string);
+};
+export type ValuePathString = string;
+export type ValuePathArray = (string | number)[];
+export type MergeStrategyMap = Record<ValuePathString, MergeStrategyDescriptor>;
+export declare const DEFAULT_MERGE_STRATEGY: MergeStrategy;
+export declare const getValuePathString: (valuePathArray?: ValuePathArray) => string;
+export declare const getValuePathArray: (valuePathString?: ValuePathString) => string[];
+export declare const isConstructedFrom: (value: any, constructorReference: Function) => boolean;
+export declare const mergeValues: (valuePathArray: ValuePathArray | undefined, existingValue: any, newValue: any, mergeStrategyMap?: MergeStrategyMap) => any;

package/src/iac/utils/patch-utils.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeValues = exports.isConstructedFrom = exports.getValuePathArray = exports.getValuePathString = exports.DEFAULT_MERGE_STRATEGY = void 0;
+exports.DEFAULT_MERGE_STRATEGY = 'transpose';
+const getValuePathString = (valuePathArray = []) => valuePathArray.map((p) => encodeURIComponent(p)).join('/');
+exports.getValuePathString = getValuePathString;
+const getValuePathArray = (valuePathString = '') => valuePathString.split('/').map((p) => decodeURIComponent(p));
+exports.getValuePathArray = getValuePathArray;
+const isConstructedFrom = (value, constructorReference) => value !== null && typeof value === 'object' && 'constructor' in value && value.constructor === constructorReference;
+exports.isConstructedFrom = isConstructedFrom;
+const mergeValues = (valuePathArray = [], existingValue, newValue, mergeStrategyMap = {}) => {
+    const valuePathString = (0, exports.getValuePathString)(valuePathArray);
+    const arrayIndexWildcardValuePathString = (0, exports.getValuePathString)(valuePathArray.map((p) => (typeof p === 'number' ? '#' : p)));
+    const { [valuePathString]: { strategy: specificKeyMergeStrategy = exports.DEFAULT_MERGE_STRATEGY, data: specificKeyMergeStrategyData = undefined } = {}, [arrayIndexWildcardValuePathString]: { strategy: arrayIndexWildcardMergeStrategy = exports.DEFAULT_MERGE_STRATEGY, data: arrayIndexWildcardMergeStrategyData = undefined, } = {}, } = 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 ((0, exports.isConstructedFrom)(existingValue, Array) && (0, exports.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) => (0, exports.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) => (0, exports.mergeValues)([...valuePathArray, index], existingValue[index], newValue[index], mergeStrategyMap));
+            }
+        }
+        else if ((0, exports.isConstructedFrom)(existingValue, Object) && (0, exports.isConstructedFrom)(newValue, Object)) {
+            mergedValue = Object.keys({ ...existingValue, ...newValue }).reduce((acc, k) => ({
+                ...acc,
+                [k]: (0, exports.mergeValues)([...valuePathArray, k], existingValue[k], newValue[k], mergeStrategyMap),
+            }), {});
+        }
+    }
+    return mergedValue;
+};
+exports.mergeValues = mergeValues;