@amazon/vinyl-util 1.0.0

package/dist/types/current/util/object/clone.d.ts

@@ -0,0 +1,68 @@
+import type { MergeRule } from './mergeDeep';
+import type { MutableDeep } from './mutableType';
+/**
+ * Merge options defines the behavior for {@link mergeDeep}.
+ * See the {@link defaultMergeOptions} for defaults that will be used if any merge options are
+ * omitted.
+ */
+export interface CloneOptions {
+    /**
+     * If an object does not pass any of the rules, if this is true the reference will be
+     * copied. If false (default), a {@link MergeReferenceError} will be thrown.
+     * This only applies to objects, not functions or primitives.
+     */
+    readonly allowReferenceCopy: boolean;
+    /**
+     * The first clone rule that matches will be used.
+     *
+     * If no rules match, the value will be copied by reference unless `allowReferenceCopy` is
+     * false (default), in which case, a {@link MergeReferenceError} will be thrown.
+     */
+    readonly rules: readonly CloneRule<any>[];
+}
+/**
+ * A CloneRule defines if and how an object should be cloned.
+ */
+export interface CloneRule<T> {
+    /**
+     * Returns true if this MergeRule should be applied for the given object.
+     * @param object
+     */
+    readonly matches: (object: any) => object is T;
+    /**
+     * Clones the given value.
+     *
+     * @param source A value guaranteed to have matched with `matches`.
+     * @param clone This callback may be used to clone sub-properties.
+     */
+    readonly clone: (source: T, clone: CloneCallback) => MutableDeep<T>;
+}
+/**
+ * A function to clone a sub-object from a clone rule.
+ */
+export type CloneCallback = <T>(
+/**
+ * The source object to clone.
+ */
+source: T, 
+/**
+ * The identifier to be used in error reporting.
+ */
+prop: string | number) => MutableDeep<T>;
+/**
+ * Performs a deep clone on the target object.
+ *
+ * This is an alias for `mergeDeep(target)` that additionally converts clone rules to one-sided
+ * merge rules.
+ *
+ * @param target The target object to clone.
+ * @param options The merge options to use.
+ * `clone`, unlike `mergeDeep`, `allowReferenceCopy` will default to false.
+ * @see mergeDeep
+ */
+export declare function clone<T>(target: T, options?: Partial<CloneOptions>): MutableDeep<T>;
+/**
+ * Creates a wrapper to convert a clone rule to a merge rule.
+ */
+export declare function toMergeRule<T>(cloneRule: CloneRule<T>): MergeRule<T>;
+//# sourceMappingURL=clone.d.ts.map

package/dist/types/current/util/object/clone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clone.d.ts","sourceRoot":"","sources":["../../../../../src/util/object/clone.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAiB,SAAS,EAAE,MAAM,aAAa,CAAA;AAE3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAEhD;;;;GAIG;AACH,MAAM,WAAW,YAAY;IACzB;;;;OAIG;IACH,QAAQ,CAAC,kBAAkB,EAAE,OAAO,CAAA;IAEpC;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,EAAE,SAAS,SAAS,CAAC,GAAG,CAAC,EAAE,CAAA;CAC5C;AAED;;GAEG;AACH,MAAM,WAAW,SAAS,CAAC,CAAC;IACxB;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,MAAM,IAAI,CAAC,CAAA;IAE9C;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,EAAE,CAAC,MAAM,EAAE,CAAC,EAAE,KAAK,EAAE,aAAa,KAAK,WAAW,CAAC,CAAC,CAAC,CAAA;CACtE;AAED;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC;AAC1B;;GAEG;AACH,MAAM,EAAE,CAAC;AAET;;GAEG;AACH,IAAI,EAAE,MAAM,GAAG,MAAM,KACpB,WAAW,CAAC,CAAC,CAAC,CAAA;AAEnB;;;;;;;;;;GAUG;AACH,wBAAgB,KAAK,CAAC,CAAC,EACnB,MAAM,EAAE,CAAC,EACT,OAAO,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,GAChC,WAAW,CAAC,CAAC,CAAC,CAMhB;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAYpE"}

package/dist/types/current/util/object/clone.js

@@ -0,0 +1,36 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { defaultMergeOptions, mergeDeep } from './mergeDeep';
+/**
+ * Performs a deep clone on the target object.
+ *
+ * This is an alias for `mergeDeep(target)` that additionally converts clone rules to one-sided
+ * merge rules.
+ *
+ * @param target The target object to clone.
+ * @param options The merge options to use.
+ * `clone`, unlike `mergeDeep`, `allowReferenceCopy` will default to false.
+ * @see mergeDeep
+ */
+export function clone(target, options) {
+    // mergeDeep works as a deep clone if given a single source.
+    return mergeDeep([target], {
+        allowReferenceCopy: options?.allowReferenceCopy ?? false,
+        rules: options?.rules?.map(toMergeRule) ?? defaultMergeOptions.rules,
+    });
+}
+/**
+ * Creates a wrapper to convert a clone rule to a merge rule.
+ */
+export function toMergeRule(cloneRule) {
+    return {
+        matches: cloneRule.matches,
+        merge(_sourceA, sourceB, merge) {
+            return cloneRule.clone(sourceB, (source, prop) => {
+                return merge(undefined, source, prop);
+            });
+        },
+    };
+}

package/dist/types/current/util/object/equalDeep.d.ts

@@ -0,0 +1,54 @@
+import type { TypedArray } from '../../util/collection/typedArray';
+/**
+ * Recursively compares the values of all the enumerable own properties from two source objects.
+ *
+ * @param objectA
+ * @param objectB
+ * @param options
+ */
+export declare function equalDeep<T>(objectA: T, objectB: T, options?: EqualOptions): boolean;
+/**
+ * Configuration for the equalDeep comparator.
+ */
+export interface EqualOptions {
+    /**
+     * The first equal rule where the first source object matches will be used.
+     * If the second object does not match, the two objects will not be considered equal.
+     */
+    readonly rules: readonly EqualRule<any>[];
+}
+/**
+ * A equal function to be provided to equal rules.
+ */
+export type EqualCallback<T = any> = (objectA: T, objectB: T) => boolean;
+export interface EqualRule<T> {
+    /**
+     * Returns true if this EqualRule should be applied for the given object.
+     * @param object
+     */
+    readonly matches: (object: any) => object is T;
+    /**
+     * Equals the two sources.
+     * @param objectA May be undefined, the first object to equal.
+     * @param objectB The second object to equal or clone if objectA is undefined.
+     * @param equal This callback may be used to equal or clone sub-properties.
+     */
+    readonly equal: (objectA: T, objectB: T, equal: EqualCallback) => boolean;
+}
+export declare const arrayEqualRule: EqualRule<any[]>;
+export declare const plainObjectEqualRule: EqualRule<Record<any, any>>;
+export declare const regexpEqualRule: EqualRule<RegExp>;
+export declare const dateEqualRule: EqualRule<Date>;
+export declare const mapEqualRule: EqualRule<Map<any, any>>;
+export declare const setEqualRule: EqualRule<Set<any>>;
+/**
+ * A typed array will always have primitive elements, compare that the lengths are equal and every
+ * element is equal.
+ */
+export declare const typedArrayEqualRule: EqualRule<TypedArray>;
+/**
+ * The default equal options provide rules for comparing arrays, plain objects, RegExp, Date,
+ * Map, Set, and TypedArray.
+ */
+export declare const defaultEqualOptions: EqualOptions;
+//# sourceMappingURL=equalDeep.d.ts.map

package/dist/types/current/util/object/equalDeep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"equalDeep.d.ts","sourceRoot":"","sources":["../../../../../src/util/object/equalDeep.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAA;AAI9D;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACvB,OAAO,EAAE,CAAC,EACV,OAAO,EAAE,CAAC,EACV,OAAO,GAAE,YAAkC,GAC5C,OAAO,CAYT;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IACzB;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,SAAS,SAAS,CAAC,GAAG,CAAC,EAAE,CAAA;CAC5C;AAED;;GAEG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,GAAG,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,KAAK,OAAO,CAAA;AAExE,MAAM,WAAW,SAAS,CAAC,CAAC;IACxB;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,MAAM,IAAI,CAAC,CAAA;IAE9C;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,EAAE,CAAC,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,aAAa,KAAK,OAAO,CAAA;CAC5E;AAED,eAAO,MAAM,cAAc,EAAE,SAAS,CAAC,GAAG,EAAE,CAYlC,CAAA;AAEV,eAAO,MAAM,oBAAoB,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,CAmBnD,CAAA;AAEV,eAAO,MAAM,eAAe,EAAE,SAAS,CAAC,MAAM,CAWpC,CAAA;AAEV,eAAO,MAAM,aAAa,EAAE,SAAS,CAAC,IAAI,CAOhC,CAAA;AAEV,eAAO,MAAM,YAAY,EAAE,SAAS,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,CAgBxC,CAAA;AAEV,eAAO,MAAM,YAAY,EAAE,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAWnC,CAAA;AAEV;;;GAGG;AACH,eAAO,MAAM,mBAAmB,EAAE,SAAS,CAAC,UAAU,CAY5C,CAAA;AAEV;;;GAGG;AACH,eAAO,MAAM,mBAAmB,EAAE,YAUxB,CAAA"}

package/dist/types/current/util/object/equalDeep.js

@@ -0,0 +1,144 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { isTypedArray } from '../../util/collection/typedArray';
+import { isPlainObject, ownKeys } from './object';
+/**
+ * Recursively compares the values of all the enumerable own properties from two source objects.
+ *
+ * @param objectA
+ * @param objectB
+ * @param options
+ */
+export function equalDeep(objectA, objectB, options = defaultEqualOptions) {
+    if (objectA === objectB)
+        return true;
+    if (objectA == null || objectB == null)
+        return false;
+    const callback = (subA, subB) => equalDeep(subA, subB, options);
+    for (const rule of options.rules) {
+        if (rule.matches(objectA)) {
+            if (!rule.matches(objectB))
+                return false;
+            return rule.equal(objectA, objectB, callback);
+        }
+    }
+    return false;
+}
+export const arrayEqualRule = {
+    matches(object) {
+        return Array.isArray(object);
+    },
+    equal(objectA, objectB, equal) {
+        if (objectA.length !== objectB.length)
+            return false;
+        for (let i = 0; i < objectA.length; i++) {
+            if (!equal(objectA[i], objectB[i]))
+                return false;
+        }
+        return true;
+    },
+};
+export const plainObjectEqualRule = {
+    matches(object) {
+        return isPlainObject(object);
+    },
+    equal(objectA, objectB, equal) {
+        const keysA = ownKeys(objectA);
+        const keysB = ownKeys(objectB);
+        if (keysA.size !== keysB.size)
+            return false;
+        for (const key of keysA) {
+            if (!(key in objectB))
+                return false;
+            if (!equal(objectA[key], objectB[key]))
+                return false;
+        }
+        return true;
+    },
+};
+export const regexpEqualRule = {
+    matches(object) {
+        return object instanceof RegExp;
+    },
+    equal(objectA, objectB, _) {
+        return (
+        // Note: legacy edge does not support flags property
+        objectA.toString() === objectB.toString() &&
+            objectA.lastIndex === objectB.lastIndex);
+    },
+};
+export const dateEqualRule = {
+    matches(object) {
+        return object instanceof Date;
+    },
+    equal(objectA, objectB, _) {
+        return objectA.getTime() === objectB.getTime();
+    },
+};
+export const mapEqualRule = {
+    matches(object) {
+        return object instanceof Map;
+    },
+    equal(objectA, objectB, equal) {
+        if (objectA.size !== objectB.size)
+            return false;
+        for (const key of objectA.keys()) {
+            if (!objectB.has(key))
+                return false;
+            if (!equal(objectA.get(key), objectB.get(key)))
+                return false;
+        }
+        return true;
+    },
+};
+export const setEqualRule = {
+    matches(object) {
+        return object instanceof Set;
+    },
+    equal(objectA, objectB, _) {
+        if (objectA.size !== objectB.size)
+            return false;
+        for (const key of objectA.keys()) {
+            if (!objectB.has(key))
+                return false;
+        }
+        return true;
+    },
+};
+/**
+ * A typed array will always have primitive elements, compare that the lengths are equal and every
+ * element is equal.
+ */
+export const typedArrayEqualRule = {
+    matches(object) {
+        return isTypedArray(object);
+    },
+    equal(objectA, objectB, _) {
+        if (objectA.length !== objectB.length)
+            return false;
+        if (objectA.byteLength !== objectB.byteLength)
+            return false;
+        for (let i = 0; i < objectA.length; i++) {
+            if (objectA[i] !== objectB[i])
+                return false;
+        }
+        return true;
+    },
+};
+/**
+ * The default equal options provide rules for comparing arrays, plain objects, RegExp, Date,
+ * Map, Set, and TypedArray.
+ */
+export const defaultEqualOptions = {
+    rules: [
+        arrayEqualRule,
+        plainObjectEqualRule,
+        regexpEqualRule,
+        dateEqualRule,
+        mapEqualRule,
+        setEqualRule,
+        typedArrayEqualRule,
+    ],
+};

package/dist/types/current/util/object/lazy.d.ts

@@ -0,0 +1,54 @@
+import type { Disposable } from '../../core/disposable';
+export interface ReadonlyLazy<T> {
+    /**
+     * True if the lazy instance has been constructed.
+     */
+    readonly constructed: boolean;
+    /**
+     * When invoked the first time, constructs the value and returns it.
+     * Consecutive calls will return that cached value.
+     * @throws DisposedError If this lazy factory is disposed.
+     */
+    get value(): T;
+}
+export interface Lazy<T> extends ReadonlyLazy<T>, Disposable {
+    /**
+     * Sets the lazy instance's value.
+     * If disposed, a {@link DisposedError} will be thrown.
+     * @param value
+     */
+    set value(value: T);
+    /**
+     * Clears the lazy instance, disposing its value.
+     * Unlike dispose(), this allows the lazy instance to be reconstructed upon the next get.
+     * Typically used only in unit testing. May be used after {@link dispose}.
+     */
+    clear(): void;
+}
+/**
+ * A factory to lazily instantiate a single cached instance.
+ */
+export declare class LazyImpl<T> implements Lazy<T>, Disposable {
+    private readonly factory;
+    private _constructing;
+    private _constructed;
+    private disposed;
+    private _value;
+    /**
+     * @param factory A factory function that will be invoked at most once.
+     */
+    constructor(factory: () => T);
+    get constructed(): boolean;
+    get value(): T;
+    set value(value: T);
+    clear(): void;
+    dispose(): void;
+}
+/**
+ * Creates a new {@link Lazy} instance.
+ *
+ * @param factory A factory function that will be invoked at most once. If the instance produced
+ * is disposable, it will be disposed on clear.
+ */
+export declare function lazy<T>(factory: () => T): Lazy<T>;
+//# sourceMappingURL=lazy.d.ts.map

package/dist/types/current/util/object/lazy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazy.d.ts","sourceRoot":"","sources":["../../../../../src/util/object/lazy.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAInD,MAAM,WAAW,YAAY,CAAC,CAAC;IAC3B;;OAEG;IACH,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAA;IAE7B;;;;OAIG;IACH,IAAI,KAAK,IAAI,CAAC,CAAA;CACjB;AAED,MAAM,WAAW,IAAI,CAAC,CAAC,CAAE,SAAQ,YAAY,CAAC,CAAC,CAAC,EAAE,UAAU;IACxD;;;;OAIG;IACH,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC,EAAC;IAEnB;;;;OAIG;IACH,KAAK,IAAI,IAAI,CAAA;CAChB;AAED;;GAEG;AACH,qBAAa,QAAQ,CAAC,CAAC,CAAE,YAAW,IAAI,CAAC,CAAC,CAAC,EAAE,UAAU;IASvC,OAAO,CAAC,QAAQ,CAAC,OAAO;IARpC,OAAO,CAAC,aAAa,CAAQ;IAC7B,OAAO,CAAC,YAAY,CAAQ;IAC5B,OAAO,CAAC,QAAQ,CAAQ;IACxB,OAAO,CAAC,MAAM,CAA2B;IAEzC;;OAEG;gBAC0B,OAAO,EAAE,MAAM,CAAC;IAE7C,IAAI,WAAW,IAAI,OAAO,CAEzB;IAED,IAAI,KAAK,IAAI,CAAC,CAUb;IAED,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC,EAKjB;IAED,KAAK,IAAI,IAAI;IAWb,OAAO;CAKV;AAED;;;;;GAKG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAEjD"}

package/dist/types/current/util/object/lazy.js

@@ -0,0 +1,70 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { DisposedError, isDisposable } from '../../core/disposable';
+import { IllegalStateError } from '../../error/IllegalStateError';
+/**
+ * A factory to lazily instantiate a single cached instance.
+ */
+export class LazyImpl {
+    factory;
+    _constructing = false;
+    _constructed = false;
+    disposed = false;
+    _value = undefined;
+    /**
+     * @param factory A factory function that will be invoked at most once.
+     */
+    constructor(factory) {
+        this.factory = factory;
+    }
+    get constructed() {
+        return this._constructed;
+    }
+    get value() {
+        if (this.disposed)
+            throw new DisposedError();
+        if (this._constructing)
+            throw new IllegalStateError('Lazy instance is constructing');
+        if (this._constructed)
+            return this._value;
+        this._constructing = true;
+        this._value = this.factory();
+        this._constructing = false;
+        this._constructed = true;
+        return this._value;
+    }
+    set value(value) {
+        if (this.disposed)
+            throw new DisposedError();
+        this.clear();
+        this._constructed = true;
+        this._value = value;
+    }
+    clear() {
+        this.disposed = false;
+        if (this._constructed) {
+            if (isDisposable(this._value)) {
+                this._value.dispose();
+            }
+            this._constructed = false;
+            this._value = undefined;
+        }
+    }
+    dispose() {
+        if (this.disposed)
+            throw new DisposedError();
+        this.clear();
+        this.disposed = true;
+    }
+}
+/**
+ * Creates a new {@link Lazy} instance.
+ *
+ * @param factory A factory function that will be invoked at most once. If the instance produced
+ * is disposable, it will be disposed on clear.
+ */
+export function lazy(factory) {
+    return new LazyImpl(factory);
+}

package/dist/types/current/util/object/merge.d.ts

@@ -0,0 +1,72 @@
+/**
+ * An intersection of T & U where common keys of T and U are overwritten by U.
+ */
+export type Merge<T, U> = Omit<T, keyof U> & U;
+/**
+ * Copy the values of all the enumerable own properties from one or more source objects to a new
+ * object.
+ *
+ * This will use `Object.assign` using a new object as the target parameter.
+ * Unlike `Object.assign`, the return type accounts for common keys.
+ *
+ * @param source1 The first source object from which to copy properties.
+ * @return Returns the new merged object.
+ */
+export declare function merge<T>(source1: T): T;
+/**
+ * Concatenates arrays.
+ *
+ * @return Returns a new concatenated array.
+ */
+export declare function merge<T>(...sources: T[][]): T[];
+/**
+ * Copy the values of all the enumerable own properties from one or more source objects to a new
+ * object.
+ *
+ * This will use `Object.assign` using a new object as the target parameter.
+ * Unlike `Object.assign`, the return type accounts for common keys.
+ *
+ * @param source1 The first source object from which to copy properties.
+ * @param source2 The second source object from which to copy properties.
+ * @return Returns the new merged object.
+ */
+export declare function merge<T, U>(source1: T, source2: U): Merge<T, U>;
+/**
+ * Copy the values of all the enumerable own properties from one or more source objects to a new
+ * object.
+ *
+ * This will use `Object.assign` using a new object as the target parameter.
+ * Unlike `Object.assign`, the return type accounts for common keys.
+ *
+ * @param source1 The first source object from which to copy properties.
+ * @param source2 The second source object from which to copy properties.
+ * @param source3 The third source object from which to copy properties.
+ * @return Returns the new merged object.
+ */
+export declare function merge<T, U, V>(source1: T, source2: U, source3: V): Merge<Merge<T, U>, V>;
+/**
+ * Copy the values of all the enumerable own properties from one or more source objects to a new
+ * object.
+ *
+ * This will use `Object.assign` using a new object as the target parameter.
+ * Unlike `Object.assign`, the return type accounts for common keys.
+ *
+ * @param source1 The first source object from which to copy properties.
+ * @param source2 The second source object from which to copy properties.
+ * @param source3 The third source object from which to copy properties.
+ * @param source4 The third source object from which to copy properties.
+ * @return Returns the new merged object.
+ */
+export declare function merge<T, U, V, W>(source1: T, source2: U, source3: V, source4: W): Merge<Merge<Merge<T, U>, V>, W>;
+/**
+ * Copy the values of all the enumerable own properties from one or more source objects to a new
+ * object.
+ *
+ * This will use `Object.assign` using a new object as the target parameter.
+ * Unlike `Object.assign`, the return type accounts for common keys.
+ *
+ * @param sources
+ * @return Returns the new merged object.
+ */
+export declare function merge(...sources: any[]): any;
+//# sourceMappingURL=merge.d.ts.map

package/dist/types/current/util/object/merge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge.d.ts","sourceRoot":"","sources":["../../../../../src/util/object/merge.ts"],"names":[],"mappings":"AAKA;;GAEG;AACH,MAAM,MAAM,KAAK,CAAC,CAAC,EAAE,CAAC,IAAI,IAAI,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,GAAG,CAAC,CAAA;AAE9C;;;;;;;;;GASG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,CAAC,CAAA;AAEvC;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,GAAG,OAAO,EAAE,CAAC,EAAE,EAAE,GAAG,CAAC,EAAE,CAAA;AAEhD;;;;;;;;;;GAUG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;AAEhE;;;;;;;;;;;GAWG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EACzB,OAAO,EAAE,CAAC,EACV,OAAO,EAAE,CAAC,EACV,OAAO,EAAE,CAAC,GACX,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;AAExB;;;;;;;;;;;;GAYG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAC5B,OAAO,EAAE,CAAC,EACV,OAAO,EAAE,CAAC,EACV,OAAO,EAAE,CAAC,EACV,OAAO,EAAE,CAAC,GACX,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;AAElC;;;;;;;;;GASG;AACH,wBAAgB,KAAK,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,GAAG,GAAG,CAAA"}

package/dist/types/current/util/object/merge.js

@@ -0,0 +1,19 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Copy the values of all the enumerable own properties from one or more source objects to a
+ * new object.
+ *
+ * This will use `Object.assign` using a new object as the target parameter.
+ *
+ * @param sources One or more source objects from which to copy properties
+ */
+export function merge(...sources) {
+    if (!sources.length)
+        return undefined;
+    if (Array.isArray(sources[0]))
+        return Array.prototype.concat(...sources);
+    return Object.assign({}, ...sources);
+}

package/dist/types/current/util/object/mergeDeep.d.ts

@@ -0,0 +1,126 @@
+import type { TypedArray } from '../../util/collection/typedArray';
+import { ReportableError } from '../../error/ReportableError';
+import { type Cloneable } from '../../core/cloneable';
+/**
+ * Concatenates multiple arrays together where each element is deeply cloned.
+ */
+export declare function mergeDeep<T extends Array<any>>(sources: readonly T[], options?: Partial<MergeOptions>): T;
+/**
+ * Deep clones the given object.
+ */
+export declare function mergeDeep<T>(sources: readonly [T], options?: Partial<MergeOptions>): T;
+/**
+ * Deep merges the two objects.
+ * If common keys are both arrays, they will be concatenated, if common keys are both objects, they
+ * will be merged. Incompatible types, e.g. an object and an array will use the later source.
+ */
+export declare function mergeDeep<A, B>(sources: readonly [A, B], options?: Partial<MergeOptions>): A & B;
+/**
+ * Deep merges the three objects.
+ * If common keys are both arrays, they will be concatenated, if common keys are both objects, they
+ * will be merged. Incompatible types, e.g. an object and an array will use the later source.
+ */
+export declare function mergeDeep<A, B, C>(sources: readonly [A, B, C], options?: Partial<MergeOptions>): A & B & C;
+/**
+ * Deep merges the four objects.
+ * If common keys are both arrays, they will be concatenated, if common keys are both objects, they
+ * will be merged. Incompatible types, e.g. an object and an array will use the later source.
+ */
+export declare function mergeDeep<A, B, C, D>(sources: readonly [A, B, C, D], options?: Partial<MergeOptions>): A & B & C & D;
+/**
+ * Deep merges the five objects.
+ * If common keys are both arrays, they will be concatenated, if common keys are both objects, they
+ * will be merged. Incompatible types, e.g. an object and an array will use the later source.
+ */
+export declare function mergeDeep<A, B, C, D, E>(sources: readonly [A, B, C, D, E], options?: Partial<MergeOptions>): A & B & C & D & E;
+/**
+ * Deep merges the six objects.
+ * If common keys are both arrays, they will be concatenated, if common keys are both objects, they
+ * will be merged. Incompatible types, e.g. an object and an array will use the later source.
+ */
+export declare function mergeDeep<A, B, C, D, E, F>(sources: readonly [A, B, C, D, E, F], options?: Partial<MergeOptions>): A & B & C & D & E & F;
+/**
+ * Deep merges all objects.
+ * If common keys are both arrays, they will be concatenated, if common keys are both objects, they
+ * will be merged. Incompatible types, e.g. an object and an array will use the later source.
+ */
+export declare function mergeDeep(sources: readonly any[], options?: Partial<MergeOptions>): any;
+/**
+ * Merge options defines the behavior for {@link mergeDeep}.
+ * See the {@link defaultMergeOptions} for defaults that will be used if any merge options are
+ * omitted.
+ */
+export interface MergeOptions {
+    /**
+     * If an object does not pass any of the rules, if this is true (default) the reference will be
+     * copied. If false, a {@link MergeReferenceError} will be thrown.
+     * This only applies to objects, not functions or primitives.
+     */
+    readonly allowReferenceCopy: boolean;
+    /**
+     * The first merge rule where the second source object matches will be used.
+     * Rules are only checked for values that have a typeof value of 'object'
+     * If the first object does not pass the match, undefined will be passed to sourceA and the
+     * rule is expected to return a clone of sourceB.
+     * If no rules match, the value will be copied by reference unless `allowReferenceCopy` is
+     * false, in which case, a {@link MergeReferenceError} will be thrown.
+     */
+    readonly rules: readonly MergeRule<any>[];
+}
+/**
+ * A merge function to be provided to merge rules.
+ */
+export type MergeCallback<T = any> = (
+/**
+ * The first like object to merge, or undefined. If undefined is provided, a
+ * clone of sourceB is expected to be returned. If defined, this object is guaranteed to have
+ * passed {@link MergeRule.matches}
+ */
+sourceA: T | undefined, 
+/**
+ * The second object to merge or clone.
+ */
+sourceB: T, 
+/**
+ * The identifier to be used in error reporting.
+ */
+prop: string | number) => T;
+export interface MergeRule<T> {
+    /**
+     * Returns true if this MergeRule should be applied for the given object.
+     * @param object
+     */
+    readonly matches: (object: any) => object is T;
+    /**
+     * Merges the two sources.
+     * @param sourceA May be undefined, the first object to merge.
+     * @param sourceB The second object to merge or clone if sourceA is undefined.
+     * @param merge This callback may be used to merge or clone sub-properties.
+     */
+    readonly merge: (sourceA: T | undefined, sourceB: T, merge: MergeCallback) => T;
+}
+export declare class MergeReferenceError extends ReportableError {
+    constructor(propPath: string, source: any);
+}
+/**
+ * Cloneable objects are not expected to be mergeable, but should be cloned.
+ */
+export declare const cloneableMergeRule: MergeRule<Cloneable<any>>;
+export declare const arrayMergeRule: MergeRule<any[]>;
+export declare const plainObjectMergeRule: MergeRule<Record<any, any>>;
+export declare const regexpMergeRule: MergeRule<RegExp>;
+export declare const dateMergeRule: MergeRule<Date>;
+export declare const mapMergeRule: MergeRule<Map<any, any>>;
+export declare const setMergeRule: MergeRule<Set<any>>;
+/**
+ * Typed arrays will not concatenate by default like arrays. Typed arrays generally represent data,
+ * not configuration, and the more reasonable default is to clone, not concatenate.
+ */
+export declare const typedArrayMergeRule: MergeRule<TypedArray>;
+export declare const urlMergeRule: MergeRule<URL>;
+/**
+ * The default merge options provide rules for merging arrays, plain objects, RegExp, Date,
+ * Map, Set, and TypedArray.
+ */
+export declare const defaultMergeOptions: MergeOptions;
+//# sourceMappingURL=mergeDeep.d.ts.map

package/dist/types/current/util/object/mergeDeep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mergeDeep.d.ts","sourceRoot":"","sources":["../../../../../src/util/object/mergeDeep.ts"],"names":[],"mappings":"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"}