v1.0 with SW PWA enabled

frontend/node_modules/smob/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-2022 Peter Placzek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

frontend/node_modules/smob/README.MD

@@ -0,0 +1,162 @@
+# SMOB 🧪
+
+[![npm version](https://badge.fury.io/js/smob.svg)](https://badge.fury.io/js/smob)
+[![main](https://github.com/tada5hi/smob/actions/workflows/main.yml/badge.svg)](https://github.com/tada5hi/smob/actions/workflows/main.yml)
+[![codecov](https://codecov.io/gh/tada5hi/smob/branch/master/graph/badge.svg?token=0VL41WO0CG)](https://codecov.io/gh/tada5hi/smob)
+[![Known Vulnerabilities](https://snyk.io/test/github/Tada5hi/smob/badge.svg?targetFile=package.json)](https://snyk.io/test/github/Tada5hi/smob?targetFile=package.json)
+[![semantic-release: angular](https://img.shields.io/badge/semantic--release-angular-e10079?logo=semantic-release)](https://github.com/semantic-release/semantic-release)
+
+A zero dependency library to **s**afe **m**erge **ob**jects and arrays with customizable behavior.
+
+**Table of Contents**
+
+- [Installation](#installation)
+- [Usage](#usage)
+  - [Merger](#merger)
+  - [Utils](#utils)
+- [License](#license)
+
+## Installation
+
+```bash
+npm install smob --save
+```
+
+## Usage
+
+```typescript
+import { merge } from "smob";
+
+const output = merge(...sources);
+```
+
+The following merge options are set by default:
+- **array**: `true` Merge object array properties.
+- **arrayDistinct**: `false` Remove duplicates, when merging array elements.
+- **arrayPriority**: `left` (options.priority) The source aka leftmost array has by **default** the highest priority.
+- **clone**: `false` Deep clone input sources.
+- **inPlace**: `false` Merge sources in place.
+- **priority**: `left` The source aka leftmost object has by **default** the highest priority.
+
+The merge behaviour can be changed by creating a custom [merger](#merger).
+
+**Arguments**
+- sources `(any[] | Record<string, any>)[]`: The source arrays/objects.
+
+```typescript
+import { merge } from 'smob';
+
+merge({ a: 1 }, { b: 2 }, { c: 3 });
+// { a: 1, b: 2, c: 3 }
+
+merge(['foo'], ['bar']);
+// ['foo', 'bar']
+
+```
+
+### Merger
+
+A custom merger can simply be created by using the `createMerger` method.
+
+**Array**
+```typescript
+import { createMerger } from 'smob';
+
+const merge = createMerger({ array: false });
+
+merge({ a: [1,2,3] }, { a: [4,5,6] });
+// { a: [1,2,3] }
+```
+
+**ArrayDistinct**
+```typescript
+import { createMerger } from 'smob';
+
+const merge = createMerger({ arrayDistinct: true });
+
+merge({ a: [1,2,3] }, { a: [3,4,5] });
+// { a: [1,2,3,4,5] }
+```
+
+**Priority**
+```typescript
+import { createMerger } from 'smob';
+
+const merge = createMerger({ priority: 'right' });
+
+merge({ a: 1 }, { a: 2 }, { a: 3 })
+// { a: 3 }
+```
+
+**Strategy**
+```typescript
+import { createMerger } from 'smob';
+
+const merge = createMerger({
+    strategy: (target, key, value) => {
+        if (
+            typeof target[key] === 'number' &&
+            typeof value === 'number'
+        ) {
+            target[key] += value;
+            return target;
+        }
+    }
+});
+
+merge({ a: 1 }, { a: 2 }, { a: 3 });
+// { a: 6 }
+```
+
+A returned value indicates that the strategy has been applied.
+
+## Utils
+
+### distinctArray
+
+```typescript
+import { distinctArray } from 'smob';
+
+distnctArray(['foo', 'bar', 'foo']);
+// ['foo', 'bar']
+```
+
+The function also removes non-primitive
+elements that are identical by value or reference.
+
+**Objects**
+```typescript
+import { distinctArray } from 'smob';
+
+distinctArray([{ foo: 'bar' }, { foo: 'bar' }]);
+// [{ foo: 'bar' }]
+```
+
+**Arrays**
+```typescript
+import { distinctArray } from 'smob';
+
+distinctArray([['foo', 'bar'], ['foo', 'bar']]);
+// [['foo', 'bar']]
+```
+
+### isEqual
+
+Checks if two (non-primitive) elements
+are identical by value or reference.
+
+````typescript
+import { isEqual } from 'smob';
+
+isEqual({foo: 'bar'}, {foo: 'bar'});
+// true
+
+isEqual(['foo', 'bar'], ['foo', 'bar']);
+// true
+````
+
+## License
+
+Made with 💚
+
+Published under [MIT License](./LICENSE).

frontend/node_modules/smob/dist/constants.d.ts

@@ -0,0 +1,4 @@
+export declare enum PriorityName {
+    LEFT = "left",
+    RIGHT = "right"
+}

frontend/node_modules/smob/dist/index.cjs

@@ -0,0 +1,283 @@
+'use strict';
+
+exports.PriorityName = void 0;
+(function(PriorityName) {
+    PriorityName["LEFT"] = "left";
+    PriorityName["RIGHT"] = "right";
+})(exports.PriorityName || (exports.PriorityName = {}));
+
+function isObject(item) {
+    return !!item && typeof item === 'object' && !Array.isArray(item);
+}
+function isSafeKey(key) {
+    return key !== '__proto__' && key !== 'prototype' && key !== 'constructor';
+}
+function isEqual(x, y) {
+    if (Object.is(x, y)) return true;
+    if (x instanceof Date && y instanceof Date) {
+        return x.getTime() === y.getTime();
+    }
+    if (x instanceof RegExp && y instanceof RegExp) {
+        return x.toString() === y.toString();
+    }
+    if (isObject(x) && isObject(y)) {
+        const keysX = Reflect.ownKeys(x);
+        const keysY = Reflect.ownKeys(y);
+        if (keysX.length !== keysY.length) {
+            return false;
+        }
+        for(let i = 0; i < keysX.length; i++){
+            const key = keysX[i];
+            if (!Reflect.has(y, key) || !isEqual(x[key], y[key])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    if (Array.isArray(x) && Array.isArray(y)) {
+        if (x.length !== y.length) {
+            return false;
+        }
+        for(let i = 0; i < x.length; i++){
+            if (!isEqual(x[i], y[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return false;
+}
+
+function distinctArray(arr) {
+    for(let i = 0; i < arr.length; i++){
+        for(let j = arr.length - 1; j > i; j--){
+            if (isEqual(arr[i], arr[j])) {
+                arr.splice(j, 1);
+            }
+        }
+    }
+    return arr;
+}
+
+/* istanbul ignore next */ const gT = (()=>{
+    if (typeof globalThis !== 'undefined') {
+        return globalThis;
+    }
+    // eslint-disable-next-line no-restricted-globals
+    if (typeof self !== 'undefined') {
+        // eslint-disable-next-line no-restricted-globals
+        return self;
+    }
+    if (typeof window !== 'undefined') {
+        return window;
+    }
+    if (typeof global !== 'undefined') {
+        return global;
+    }
+    throw new Error('unable to locate global object');
+})();
+function polyfillClone(input) {
+    const map = new WeakMap();
+    const fn = (value)=>{
+        if (Array.isArray(value)) {
+            if (map.has(value)) {
+                return map.get(value);
+            }
+            const cloned = [];
+            map.set(value, cloned);
+            value.map((el)=>cloned.push(fn(el)));
+            return cloned;
+        }
+        if (isObject(value)) {
+            if (map.has(value)) {
+                return map.get(value);
+            }
+            const output = {};
+            const keys = Object.keys(value);
+            map.set(value, output);
+            for(let i = 0; i < keys.length; i++){
+                output[keys[i]] = fn(value[keys[i]]);
+            }
+            return output;
+        }
+        return value;
+    };
+    return fn(input);
+}
+/* istanbul ignore next */ function clone(value) {
+    if (gT.structuredClone) {
+        return gT.structuredClone(value);
+    }
+    /* istanbul ignore next */ return polyfillClone(value);
+}
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+function hasOwnProperty(obj, prop) {
+    return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+
+function buildOptions(options = {}) {
+    var _options_array;
+    options.array = (_options_array = options.array) != null ? _options_array : true;
+    var _options_arrayDistinct;
+    options.arrayDistinct = (_options_arrayDistinct = options.arrayDistinct) != null ? _options_arrayDistinct : false;
+    var _options_clone;
+    options.clone = (_options_clone = options.clone) != null ? _options_clone : false;
+    var _options_inPlace;
+    options.inPlace = (_options_inPlace = options.inPlace) != null ? _options_inPlace : false;
+    options.priority = options.priority || exports.PriorityName.LEFT;
+    options.arrayPriority = options.arrayPriority || options.priority;
+    return options;
+}
+function togglePriority(priority) {
+    return priority === exports.PriorityName.LEFT ? `${exports.PriorityName.RIGHT}` : `${exports.PriorityName.LEFT}`;
+}
+
+function baseMerger(context, ...sources) {
+    let target;
+    let source;
+    let { priority } = context.options;
+    if (sources.length >= 2) {
+        if (Array.isArray(sources.at(0)) && Array.isArray(sources.at(-1))) {
+            priority = context.options.arrayPriority;
+        }
+    }
+    if (priority === exports.PriorityName.RIGHT) {
+        target = sources.pop();
+        source = sources.pop();
+    } else {
+        target = sources.shift();
+        source = sources.shift();
+    }
+    if (!source) {
+        if (Array.isArray(target) && context.options.arrayDistinct) {
+            return distinctArray(target);
+        }
+        return target;
+    }
+    if (Array.isArray(target) && Array.isArray(source)) {
+        target.push(...source);
+        if (context.options.arrayPriority === exports.PriorityName.RIGHT) {
+            return baseMerger(context, ...sources, target);
+        }
+        return baseMerger(context, target, ...sources);
+    }
+    context.map.set(source, true);
+    if (isObject(target) && isObject(source)) {
+        const keys = Object.keys(source);
+        for(let i = 0; i < keys.length; i++){
+            const key = keys[i];
+            if (hasOwnProperty(target, key)) {
+                if (!isSafeKey(key)) {
+                    continue;
+                }
+                if (context.options.strategy) {
+                    const applied = context.options.strategy(target, key, source[key]);
+                    if (typeof applied !== 'undefined') {
+                        continue;
+                    }
+                }
+                if (isObject(target[key]) && isObject(source[key])) {
+                    if (context.map.has(source[key])) {
+                        const sourceKeys = Object.keys(source[key]);
+                        for(let j = 0; j < sourceKeys.length; j++){
+                            if (isSafeKey(sourceKeys[j]) && !hasOwnProperty(target[key], sourceKeys[j])) {
+                                target[key][sourceKeys[j]] = source[key][sourceKeys[j]];
+                            }
+                        }
+                        continue;
+                    }
+                    if (context.options.priority === exports.PriorityName.RIGHT) {
+                        target[key] = baseMerger(context, source[key], target[key]);
+                    } else {
+                        target[key] = baseMerger(context, target[key], source[key]);
+                    }
+                    continue;
+                }
+                if (context.options.array && Array.isArray(target[key]) && Array.isArray(source[key])) {
+                    const arrayPriority = context.options.priority !== context.options.arrayPriority ? togglePriority(context.options.arrayPriority) : context.options.arrayPriority;
+                    switch(arrayPriority){
+                        case exports.PriorityName.LEFT:
+                            Object.assign(target, {
+                                [key]: baseMerger(context, target[key], source[key])
+                            });
+                            break;
+                        case exports.PriorityName.RIGHT:
+                            Object.assign(target, {
+                                [key]: baseMerger(context, source[key], target[key])
+                            });
+                            break;
+                    }
+                }
+            } else {
+                Object.assign(target, {
+                    [key]: source[key]
+                });
+            }
+        }
+    }
+    context.map = new WeakMap();
+    if (context.options.priority === exports.PriorityName.RIGHT) {
+        return baseMerger(context, ...sources, target);
+    }
+    return baseMerger(context, target, ...sources);
+}
+function createMerger(input) {
+    const options = buildOptions(input);
+    return (...sources)=>{
+        if (!sources.length) {
+            throw new SyntaxError('At least one input element is required.');
+        }
+        const ctx = {
+            options,
+            map: new WeakMap()
+        };
+        if (options.clone) {
+            return baseMerger(ctx, ...clone(sources));
+        }
+        if (!options.inPlace) {
+            if (Array.isArray(sources.at(0)) && options.arrayPriority === exports.PriorityName.LEFT) {
+                sources.unshift([]);
+                return baseMerger(ctx, ...sources);
+            }
+            if (Array.isArray(sources.at(-1)) && options.arrayPriority === exports.PriorityName.RIGHT) {
+                sources.push([]);
+                return baseMerger(ctx, ...sources);
+            }
+            if (options.priority === exports.PriorityName.LEFT) {
+                sources.unshift({});
+            } else {
+                sources.push({});
+            }
+        }
+        return baseMerger(ctx, ...sources);
+    };
+}
+const merge = createMerger();
+
+/**
+ * Assign source attributes to a target object.
+ *
+ * @param target
+ * @param sources
+ */ function assign(target, ...sources) {
+    return createMerger({
+        inPlace: true,
+        priority: 'left',
+        array: false
+    })(target, ...sources);
+}
+
+exports.assign = assign;
+exports.buildOptions = buildOptions;
+exports.clone = clone;
+exports.createMerger = createMerger;
+exports.distinctArray = distinctArray;
+exports.hasOwnProperty = hasOwnProperty;
+exports.isEqual = isEqual;
+exports.isObject = isObject;
+exports.isSafeKey = isSafeKey;
+exports.merge = merge;
+exports.polyfillClone = polyfillClone;
+exports.togglePriority = togglePriority;
+//# sourceMappingURL=index.cjs.map

frontend/node_modules/smob/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './constants';
+export * from './module';
+export * from './utils';
+export * from './presets';
+export * from './type';

frontend/node_modules/smob/dist/index.mjs

@@ -0,0 +1,270 @@
+var PriorityName;
+(function(PriorityName) {
+    PriorityName["LEFT"] = "left";
+    PriorityName["RIGHT"] = "right";
+})(PriorityName || (PriorityName = {}));
+
+function isObject(item) {
+    return !!item && typeof item === 'object' && !Array.isArray(item);
+}
+function isSafeKey(key) {
+    return key !== '__proto__' && key !== 'prototype' && key !== 'constructor';
+}
+function isEqual(x, y) {
+    if (Object.is(x, y)) return true;
+    if (x instanceof Date && y instanceof Date) {
+        return x.getTime() === y.getTime();
+    }
+    if (x instanceof RegExp && y instanceof RegExp) {
+        return x.toString() === y.toString();
+    }
+    if (isObject(x) && isObject(y)) {
+        const keysX = Reflect.ownKeys(x);
+        const keysY = Reflect.ownKeys(y);
+        if (keysX.length !== keysY.length) {
+            return false;
+        }
+        for(let i = 0; i < keysX.length; i++){
+            const key = keysX[i];
+            if (!Reflect.has(y, key) || !isEqual(x[key], y[key])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    if (Array.isArray(x) && Array.isArray(y)) {
+        if (x.length !== y.length) {
+            return false;
+        }
+        for(let i = 0; i < x.length; i++){
+            if (!isEqual(x[i], y[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return false;
+}
+
+function distinctArray(arr) {
+    for(let i = 0; i < arr.length; i++){
+        for(let j = arr.length - 1; j > i; j--){
+            if (isEqual(arr[i], arr[j])) {
+                arr.splice(j, 1);
+            }
+        }
+    }
+    return arr;
+}
+
+/* istanbul ignore next */ const gT = (()=>{
+    if (typeof globalThis !== 'undefined') {
+        return globalThis;
+    }
+    // eslint-disable-next-line no-restricted-globals
+    if (typeof self !== 'undefined') {
+        // eslint-disable-next-line no-restricted-globals
+        return self;
+    }
+    if (typeof window !== 'undefined') {
+        return window;
+    }
+    if (typeof global !== 'undefined') {
+        return global;
+    }
+    throw new Error('unable to locate global object');
+})();
+function polyfillClone(input) {
+    const map = new WeakMap();
+    const fn = (value)=>{
+        if (Array.isArray(value)) {
+            if (map.has(value)) {
+                return map.get(value);
+            }
+            const cloned = [];
+            map.set(value, cloned);
+            value.map((el)=>cloned.push(fn(el)));
+            return cloned;
+        }
+        if (isObject(value)) {
+            if (map.has(value)) {
+                return map.get(value);
+            }
+            const output = {};
+            const keys = Object.keys(value);
+            map.set(value, output);
+            for(let i = 0; i < keys.length; i++){
+                output[keys[i]] = fn(value[keys[i]]);
+            }
+            return output;
+        }
+        return value;
+    };
+    return fn(input);
+}
+/* istanbul ignore next */ function clone(value) {
+    if (gT.structuredClone) {
+        return gT.structuredClone(value);
+    }
+    /* istanbul ignore next */ return polyfillClone(value);
+}
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+function hasOwnProperty(obj, prop) {
+    return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+
+function buildOptions(options = {}) {
+    var _options_array;
+    options.array = (_options_array = options.array) != null ? _options_array : true;
+    var _options_arrayDistinct;
+    options.arrayDistinct = (_options_arrayDistinct = options.arrayDistinct) != null ? _options_arrayDistinct : false;
+    var _options_clone;
+    options.clone = (_options_clone = options.clone) != null ? _options_clone : false;
+    var _options_inPlace;
+    options.inPlace = (_options_inPlace = options.inPlace) != null ? _options_inPlace : false;
+    options.priority = options.priority || PriorityName.LEFT;
+    options.arrayPriority = options.arrayPriority || options.priority;
+    return options;
+}
+function togglePriority(priority) {
+    return priority === PriorityName.LEFT ? `${PriorityName.RIGHT}` : `${PriorityName.LEFT}`;
+}
+
+function baseMerger(context, ...sources) {
+    let target;
+    let source;
+    let { priority } = context.options;
+    if (sources.length >= 2) {
+        if (Array.isArray(sources.at(0)) && Array.isArray(sources.at(-1))) {
+            priority = context.options.arrayPriority;
+        }
+    }
+    if (priority === PriorityName.RIGHT) {
+        target = sources.pop();
+        source = sources.pop();
+    } else {
+        target = sources.shift();
+        source = sources.shift();
+    }
+    if (!source) {
+        if (Array.isArray(target) && context.options.arrayDistinct) {
+            return distinctArray(target);
+        }
+        return target;
+    }
+    if (Array.isArray(target) && Array.isArray(source)) {
+        target.push(...source);
+        if (context.options.arrayPriority === PriorityName.RIGHT) {
+            return baseMerger(context, ...sources, target);
+        }
+        return baseMerger(context, target, ...sources);
+    }
+    context.map.set(source, true);
+    if (isObject(target) && isObject(source)) {
+        const keys = Object.keys(source);
+        for(let i = 0; i < keys.length; i++){
+            const key = keys[i];
+            if (hasOwnProperty(target, key)) {
+                if (!isSafeKey(key)) {
+                    continue;
+                }
+                if (context.options.strategy) {
+                    const applied = context.options.strategy(target, key, source[key]);
+                    if (typeof applied !== 'undefined') {
+                        continue;
+                    }
+                }
+                if (isObject(target[key]) && isObject(source[key])) {
+                    if (context.map.has(source[key])) {
+                        const sourceKeys = Object.keys(source[key]);
+                        for(let j = 0; j < sourceKeys.length; j++){
+                            if (isSafeKey(sourceKeys[j]) && !hasOwnProperty(target[key], sourceKeys[j])) {
+                                target[key][sourceKeys[j]] = source[key][sourceKeys[j]];
+                            }
+                        }
+                        continue;
+                    }
+                    if (context.options.priority === PriorityName.RIGHT) {
+                        target[key] = baseMerger(context, source[key], target[key]);
+                    } else {
+                        target[key] = baseMerger(context, target[key], source[key]);
+                    }
+                    continue;
+                }
+                if (context.options.array && Array.isArray(target[key]) && Array.isArray(source[key])) {
+                    const arrayPriority = context.options.priority !== context.options.arrayPriority ? togglePriority(context.options.arrayPriority) : context.options.arrayPriority;
+                    switch(arrayPriority){
+                        case PriorityName.LEFT:
+                            Object.assign(target, {
+                                [key]: baseMerger(context, target[key], source[key])
+                            });
+                            break;
+                        case PriorityName.RIGHT:
+                            Object.assign(target, {
+                                [key]: baseMerger(context, source[key], target[key])
+                            });
+                            break;
+                    }
+                }
+            } else {
+                Object.assign(target, {
+                    [key]: source[key]
+                });
+            }
+        }
+    }
+    context.map = new WeakMap();
+    if (context.options.priority === PriorityName.RIGHT) {
+        return baseMerger(context, ...sources, target);
+    }
+    return baseMerger(context, target, ...sources);
+}
+function createMerger(input) {
+    const options = buildOptions(input);
+    return (...sources)=>{
+        if (!sources.length) {
+            throw new SyntaxError('At least one input element is required.');
+        }
+        const ctx = {
+            options,
+            map: new WeakMap()
+        };
+        if (options.clone) {
+            return baseMerger(ctx, ...clone(sources));
+        }
+        if (!options.inPlace) {
+            if (Array.isArray(sources.at(0)) && options.arrayPriority === PriorityName.LEFT) {
+                sources.unshift([]);
+                return baseMerger(ctx, ...sources);
+            }
+            if (Array.isArray(sources.at(-1)) && options.arrayPriority === PriorityName.RIGHT) {
+                sources.push([]);
+                return baseMerger(ctx, ...sources);
+            }
+            if (options.priority === PriorityName.LEFT) {
+                sources.unshift({});
+            } else {
+                sources.push({});
+            }
+        }
+        return baseMerger(ctx, ...sources);
+    };
+}
+const merge = createMerger();
+
+/**
+ * Assign source attributes to a target object.
+ *
+ * @param target
+ * @param sources
+ */ function assign(target, ...sources) {
+    return createMerger({
+        inPlace: true,
+        priority: 'left',
+        array: false
+    })(target, ...sources);
+}
+
+export { PriorityName, assign, buildOptions, clone, createMerger, distinctArray, hasOwnProperty, isEqual, isObject, isSafeKey, merge, polyfillClone, togglePriority };
+//# sourceMappingURL=index.mjs.map

frontend/node_modules/smob/dist/module.d.ts

@@ -0,0 +1,3 @@
+import type { Merger, OptionsInput } from './type';
+export declare function createMerger(input?: OptionsInput): Merger;
+export declare const merge: Merger;

frontend/node_modules/smob/dist/presets.d.ts

@@ -0,0 +1,8 @@
+import type { MergerResult } from './type';
+/**
+ * Assign source attributes to a target object.
+ *
+ * @param target
+ * @param sources
+ */
+export declare function assign<A extends Record<string, any>, B extends Record<string, any>[]>(target: A, ...sources: B): A & MergerResult<B>;

frontend/node_modules/smob/dist/type.d.ts

@@ -0,0 +1,60 @@
+import type { PriorityName } from './constants';
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+export type Options = {
+    /**
+     * Merge object array properties.
+     *
+     * default: true
+     */
+    array: boolean;
+    /**
+     * Remove duplicates, when merging array elements.
+     *
+     * default: false
+     */
+    arrayDistinct: boolean;
+    /**
+     * Merge sources from left-to-right or right-to-left.
+     * From v2 upwards default to left independent of the option priority.
+     *
+     * default: left (aka. options.priority)
+     */
+    arrayPriority: `${PriorityName}`;
+    /**
+     * Strategy to merge different object keys.
+     *
+     * @param target
+     * @param key
+     * @param value
+     */
+    strategy?: (target: Record<string, any>, key: string, value: unknown) => Record<string, any> | undefined;
+    /**
+     * Merge sources in place.
+     *
+     * default: false
+     */
+    inPlace?: boolean;
+    /**
+     * Deep clone input sources.
+     *
+     * default: false
+     */
+    clone?: boolean;
+    /**
+     * Merge sources from left-to-right or right-to-left.
+     * From v2 upwards default to right.
+     *
+     * default: left
+     */
+    priority: `${PriorityName}`;
+};
+export type OptionsInput = Partial<Options>;
+export type MergerSource = any[] | Record<string, any>;
+export type MergerSourceUnwrap<T extends MergerSource> = T extends Array<infer Return> ? Return : T;
+export type MergerResult<B extends MergerSource> = UnionToIntersection<MergerSourceUnwrap<B>>;
+export type MergerContext = {
+    options: Options;
+    map: WeakMap<any, any>;
+};
+export type Merger = <B extends MergerSource[]>(...sources: B) => MergerResult<B>;
+export {};

frontend/node_modules/smob/dist/utils/array.d.ts

@@ -0,0 +1 @@
+export declare function distinctArray<T = any>(arr: T[]): T[];

frontend/node_modules/smob/dist/utils/check.d.ts

@@ -0,0 +1,3 @@
+export declare function isObject(item: unknown): item is Record<string, any>;
+export declare function isSafeKey(key: string): boolean;
+export declare function isEqual(x: any, y: any): boolean;

frontend/node_modules/smob/dist/utils/clone.d.ts

@@ -0,0 +1,2 @@
+export declare function polyfillClone<T>(input: T): T;
+export declare function clone<T>(value: T): T;

frontend/node_modules/smob/dist/utils/index.d.ts

@@ -0,0 +1,5 @@
+export * from './array';
+export * from './check';
+export * from './clone';
+export * from './object';
+export * from './options';

frontend/node_modules/smob/dist/utils/object.d.ts

@@ -0,0 +1 @@
+export declare function hasOwnProperty<X extends {}, Y extends PropertyKey>(obj: X, prop: Y): obj is X & Record<Y, unknown>;

frontend/node_modules/smob/dist/utils/options.d.ts

@@ -0,0 +1,4 @@
+import { PriorityName } from '../constants';
+import type { Options, OptionsInput } from '../type';
+export declare function buildOptions(options?: OptionsInput): Options;
+export declare function togglePriority(priority: `${PriorityName}`): "left" | "right";

frontend/node_modules/smob/package.json

@@ -0,0 +1,71 @@
+{
+    "name": "smob",
+    "version": "1.5.0",
+    "description": "Zero dependency library to safe merge objects.",
+    "main": "dist/index.cjs",
+    "module": "dist/index.mjs",
+    "types": "dist/index.d.ts",
+    "exports": {
+        "./package.json": "./package.json",
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.mjs",
+            "require": "./dist/index.cjs"
+        }
+    },
+    "files": [
+        "dist/"
+    ],
+    "scripts": {
+        "build:types": "tsc --emitDeclarationOnly",
+        "build:js": "rollup -c",
+        "build": "rimraf dist && npm run build:types && npm run build:js",
+        "commit": "npx git-cz",
+        "lint": "eslint --ext .js,.ts ./src",
+        "lint:fix": "npm run lint -- --fix",
+        "test": "cross-env NODE_ENV=test jest --config ./test/jest.config.js",
+        "test:coverage": "npm run test -- --coverage",
+        "prepare": "npx husky install",
+        "prepublishOnly": "npm run build"
+    },
+    "author": {
+        "name": "Peter Placzek",
+        "email": "contact@tada5hi.net",
+        "url": "https://github.com/tada5hi"
+    },
+    "license": "MIT",
+    "keywords": [
+        "object",
+        "object-merge",
+        "merge",
+        "safe",
+        "deep-merge",
+        "merge-deep"
+    ],
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/Tada5hi/smob.git"
+    },
+    "bugs": {
+        "url": "https://github.com/Tada5hi/smob/issues"
+    },
+    "homepage": "https://github.com/Tada5hi/smob#readme",
+    "devDependencies": {
+        "@rollup/plugin-node-resolve": "^15.2.3",
+        "@swc/core": "^1.4.11",
+        "@swc/jest": "^0.2.29",
+        "@tada5hi/commitlint-config": "^1.2.0",
+        "@tada5hi/eslint-config-typescript": "^1.2.10",
+        "@tada5hi/semantic-release": "^0.3.1",
+        "@tada5hi/tsconfig": "^0.5.1",
+        "@types/jest": "^29.5.3",
+        "@types/node": "^20.10.4",
+        "cross-env": "^7.0.3",
+        "eslint": "^8.57.0",
+        "husky": "^9.0.11",
+        "jest": "^29.6.1",
+        "rollup": "^4.13.2",
+        "semantic-release": "^23.0.6",
+        "typescript": "^5.4.3"
+    }
+}