@nanahoshi/mona-ui 0.1.0

package/fesm2022/nanahoshi-mona-ui-common.mjs

@@ -0,0 +1,642 @@
+import * as i0 from '@angular/core';
+import { Pipe, linkedSignal, computed, signal } from '@angular/core';
+import { any, contains, all, from, firstOrDefault, ImmutableDictionary } from '@mirei/ts-collections';
+import { DateTime } from 'luxon';
+
+class PreventableEvent {
+    #event;
+    #type;
+    #defaultPrevented = false;
+    constructor(type, event) {
+        this.#type = type;
+        this.#event = event;
+    }
+    isDefaultPrevented() {
+        return this.#defaultPrevented;
+    }
+    preventDefault() {
+        this.#defaultPrevented = true;
+    }
+    get originalEvent() {
+        return this.#event;
+    }
+    get type() {
+        return this.#type;
+    }
+}
+
+class FilterChangeEvent extends PreventableEvent {
+    #filter;
+    constructor(filterText) {
+        super("filterInputChange");
+        this.#filter = filterText;
+    }
+    get filter() {
+        return this.#filter;
+    }
+}
+
+class AnyPipe {
+    transform(sequence, predicate) {
+        if (sequence == null) {
+            return false;
+        }
+        if (!predicate) {
+            return any(sequence);
+        }
+        return any(sequence, predicate);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.6", ngImport: i0, type: AnyPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "22.0.6", ngImport: i0, type: AnyPipe, isStandalone: true, name: "monaAny" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.6", ngImport: i0, type: AnyPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: "monaAny"
+                }]
+        }] });
+
+class ContainsPipe {
+    transform(sequence, value) {
+        if (sequence == null) {
+            return false;
+        }
+        if (typeof value === "string") {
+            return contains(sequence, value);
+        }
+        if (Symbol.iterator in Object(value)) {
+            return all(value, item => contains(sequence, item));
+        }
+        return contains(sequence, value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.6", ngImport: i0, type: ContainsPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "22.0.6", ngImport: i0, type: ContainsPipe, isStandalone: true, name: "monaContains" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.6", ngImport: i0, type: ContainsPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: "monaContains"
+                }]
+        }] });
+
+class SlicePipe {
+    transform(value, start, end) {
+        return from(value)
+            .skip(start)
+            .take(end - start)
+            .toArray();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.6", ngImport: i0, type: SlicePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "22.0.6", ngImport: i0, type: SlicePipe, isStandalone: true, name: "monaSlice" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.6", ngImport: i0, type: SlicePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: "monaSlice"
+                }]
+        }] });
+
+class TakeFirstPipe {
+    transform(value) {
+        if (value == null) {
+            return null;
+        }
+        return firstOrDefault(value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.6", ngImport: i0, type: TakeFirstPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "22.0.6", ngImport: i0, type: TakeFirstPipe, isStandalone: true, name: "monaTakeFirst" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.6", ngImport: i0, type: TakeFirstPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: "monaTakeFirst"
+                }]
+        }] });
+
+const defaultOptions = { arrayStrategy: { kind: "replace" } };
+const isEmptyObject = (obj) => {
+    return Object.keys(obj).length === 0;
+};
+const isPlainObject = (v) => {
+    return !!v && typeof v === "object" && Object.getPrototypeOf(v) === Object.prototype;
+};
+function deepMerge(base, patch, options = defaultOptions, path = []) {
+    if (!isPlainObject(patch)) {
+        return base;
+    }
+    const out = isPlainObject(base) ? { ...base } : {};
+    const keys = Object.keys(patch);
+    for (const key of keys) {
+        const patchValue = patch[key];
+        if (patchValue === undefined) {
+            continue;
+        }
+        const baseValue = out[key];
+        const currentPath = [...path, key];
+        if (Array.isArray(patchValue)) {
+            const rawStrategy = options.arrayStrategy ?? defaultOptions.arrayStrategy;
+            const strategy = typeof rawStrategy === "function" ? rawStrategy(key, currentPath) : rawStrategy;
+            if (strategy.kind === "replace" || !Array.isArray(baseValue)) {
+                out[key] = patchValue;
+            }
+            else if (strategy.kind === "concat") {
+                out[key] = [
+                    ...baseValue,
+                    ...patchValue
+                ];
+            }
+            else {
+                // unionBy Strategy
+                const by = strategy.key;
+                const map = new Map();
+                const getIdentifier = (item) => {
+                    if (Array.isArray(by)) {
+                        return by.map(k => String(item?.[k] ?? "")).join("|");
+                    }
+                    return String(item?.[by] ?? "");
+                };
+                for (const item of baseValue) {
+                    map.set(getIdentifier(item), item);
+                }
+                for (const item of patchValue) {
+                    const id = getIdentifier(item);
+                    const existing = map.get(id);
+                    const mergedItem = isPlainObject(item) && isPlainObject(existing)
+                        ? // @ts-ignore // TODO: Remove this when it is no longer flagged as error
+                            deepMerge(existing, item, options)
+                        : { ...existing, ...item };
+                    map.set(id, mergedItem);
+                }
+                out[key] = Array.from(map.values());
+            }
+            continue;
+        }
+        if (isPlainObject(patchValue) && isPlainObject(baseValue)) {
+            out[key] = deepMerge(baseValue, patchValue, options, currentPath);
+            continue;
+        }
+        out[key] = patchValue;
+    }
+    return out;
+}
+function mergeInto(base, patch, options) {
+    return deepMerge(base, patch, options);
+}
+function mergePatchInto(base, patch, options) {
+    return deepMerge(base, patch, options);
+}
+function buildNested(keys, leaf) {
+    const [head, ...rest] = keys;
+    if (head === undefined) {
+        return {};
+    }
+    if (rest.length === 0) {
+        return { [head]: leaf };
+    }
+    return { [head]: buildNested(rest, leaf) };
+}
+function patchAt(path, value) {
+    const keys = path;
+    const nested = buildNested(keys, value);
+    return nested;
+}
+function setAt(obj, path, value, options) {
+    return deepMerge(obj, patchAt(path, value), options);
+}
+function prunePatch(base, patch) {
+    if (patch === null || typeof patch !== "object" || base === null || typeof base !== "object") {
+        return base === patch ? undefined : patch;
+    }
+    const baseObj = base;
+    const patchObj = patch;
+    const result = { ...patchObj };
+    for (const key of Object.keys(patchObj)) {
+        if (!(key in baseObj)) {
+            continue;
+        }
+        const baseValue = baseObj[key];
+        const patchValue = patchObj[key];
+        if (isPlainObject(patchValue) && isPlainObject(baseValue)) {
+            const pruned = prunePatch(baseValue, patchValue);
+            if (pruned === undefined || (typeof pruned === "object" && Object.keys(pruned).length === 0)) {
+                delete result[key];
+            }
+            else {
+                result[key] = pruned;
+            }
+        }
+        else if (deepEquals(baseValue, patchValue)) {
+            delete result[key];
+        }
+    }
+    return Object.keys(result).length === 0 ? undefined : result;
+}
+function deepEquals(o1, o2) {
+    if (o1 === o2) {
+        return true;
+    }
+    if (typeof o1 !== typeof o2 || o1 === null || o2 === null || o1 === undefined || o2 === undefined) {
+        return false;
+    }
+    if (o1 instanceof Date && o2 instanceof Date) {
+        return DateTime.fromJSDate(o1).equals(DateTime.fromJSDate(o2));
+    }
+    if (Array.isArray(o1) !== Array.isArray(o2)) {
+        return false;
+    }
+    if (Array.isArray(o1) && Array.isArray(o2)) {
+        return o1.length === o2.length && o1.every((v, i) => deepEquals(v, o2[i]));
+    }
+    if (typeof o1 === "object" && typeof o2 === "object") {
+        const keys1 = Object.keys(o1);
+        const keys2 = Object.keys(o2);
+        if (keys1.length !== keys2.length) {
+            return false;
+        }
+        for (const key of keys1) {
+            const keyOfT = key;
+            if (!Object.prototype.hasOwnProperty.call(o2, key) || !deepEquals(o1[keyOfT], o2[keyOfT])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return false;
+}
+
+class ObjectPatchStore {
+    #base;
+    #committed;
+    #draft;
+    #options;
+    constructor(options) {
+        this.#draft = linkedSignal({ ...(ngDevMode ? { debugName: "#draft" } : /* istanbul ignore next */ {}), source: () => this.#base(),
+            computation: (newBase, previous) => {
+                const strategy = this.#options.baseChangeStrategy ?? "wipe";
+                if (!previous) {
+                    // First computation — initialise from options.initial if provided.
+                    return this.#options.initial?.() ?? {};
+                }
+                switch (strategy) {
+                    case "preserve":
+                        return previous.value;
+                    case "rebase":
+                        return prunePatch(newBase, previous.value) ?? {};
+                    case "wipe":
+                    default:
+                        return {};
+                }
+            } });
+        this.changes = computed(() => {
+            const draft = this.#draft();
+            return isEmptyObject(draft) ? undefined : draft;
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "changes" }] : /* istanbul ignore next */ []));
+        this.pristine = computed(() => {
+            const base = this.#base();
+            const draft = this.#draft();
+            const committed = this.#committed();
+            const prunedDraft = prunePatch(base, draft) ?? {};
+            const prunedCommitted = prunePatch(base, committed) ?? {};
+            return deepEquals(prunedDraft, prunedCommitted);
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "pristine" }] : /* istanbul ignore next */ []));
+        this.view = computed(() => deepMerge(this.#base(), this.#draft()), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "view" }] : /* istanbul ignore next */ []));
+        this.#options = options;
+        this.#base = options.source();
+        const initial = options.initial?.() ?? {};
+        this.#committed = signal(initial, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "#committed" }] : /* istanbul ignore next */ []));
+        // Sync initial draft; linkedSignal computation handles subsequent base changes.
+        this.#draft.set(initial);
+    }
+    clear() {
+        this.#draft.set({});
+    }
+    commit() {
+        this.#committed.set(this.#draft());
+    }
+    getCommitted() {
+        return this.#committed();
+    }
+    hasDraft() {
+        return !isEmptyObject(this.#draft());
+    }
+    patch(patch, options) {
+        const effectiveOptions = options ?? this.#options.mergeOptions;
+        this.#draft.update(currentDraft => {
+            const currentFullView = deepMerge(this.#base(), currentDraft, effectiveOptions);
+            const updatedFullView = deepMerge(currentFullView, patch, effectiveOptions);
+            const nextDraft = prunePatch(this.#base(), updatedFullView);
+            return nextDraft ?? {};
+        });
+    }
+    patchPath(path, value, options) {
+        const patch = buildNested(path, value);
+        this.patch(patch, options);
+    }
+    reset() {
+        this.#draft.set({});
+        this.#committed.set({});
+    }
+    setDraft(patch) {
+        this.#draft.set(patch);
+    }
+    setPath(path, value, options) {
+        // Fix: delegate to patch() so the draft is merged rather than replaced,
+        // preserving any unrelated in-progress changes.
+        const patch = buildNested(path, value);
+        this.patch(patch, options);
+    }
+    select(projector, equal = deepEquals) {
+        return computed(() => projector(this.view()), { equal });
+    }
+}
+class IterablePatchStore {
+    #base;
+    /**
+     * O(1) lookup map derived from the base signal. Rebuilt only when the
+     * base iterable emits a new value, not on every patch operation.
+     */
+    #baseMap;
+    #committed;
+    #drafts;
+    #options;
+    /**
+     * Memoisation cache for the `view` computed. Keyed by item id; each
+     * entry stores the draft reference that produced the merged result so we
+     * can skip deepMerge when neither the base item nor its draft changed.
+     */
+    #viewCache;
+    constructor(options) {
+        /**
+         * O(1) lookup map derived from the base signal. Rebuilt only when the
+         * base iterable emits a new value, not on every patch operation.
+         */
+        this.#baseMap = computed(() => new Map(Array.from(this.#base()).map(item => [this.#options.idOf(item), item])), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "#baseMap" }] : /* istanbul ignore next */ []));
+        this.#drafts = linkedSignal({ ...(ngDevMode ? { debugName: "#drafts" } : /* istanbul ignore next */ {}), source: () => this.#options.source(),
+            computation: (newSource, previous) => {
+                const strategy = this.#options.baseChangeStrategy ?? "wipe";
+                if (!previous) {
+                    return ImmutableDictionary.create();
+                }
+                switch (strategy) {
+                    case "preserve":
+                        return previous.value;
+                    case "rebase": {
+                        const baseArray = Array.from(newSource());
+                        let rebased = ImmutableDictionary.create();
+                        for (const [id, draft] of previous.value.entries()) {
+                            const baseItem = baseArray.find(item => this.#options.idOf(item) === id);
+                            if (!baseItem) {
+                                // Item no longer exists in base — drop the draft.
+                                continue;
+                            }
+                            const pruned = prunePatch(baseItem, draft);
+                            if (pruned && !isEmptyObject(pruned)) {
+                                rebased = rebased.put(id, pruned);
+                            }
+                        }
+                        return rebased;
+                    }
+                    case "wipe":
+                    default:
+                        return ImmutableDictionary.create();
+                }
+            } });
+        /**
+         * Memoisation cache for the `view` computed. Keyed by item id; each
+         * entry stores the draft reference that produced the merged result so we
+         * can skip deepMerge when neither the base item nor its draft changed.
+         */
+        this.#viewCache = new Map();
+        this.changes = computed(() => {
+            const baseArray = Array.from(this.#base());
+            const drafts = this.#drafts();
+            return baseArray
+                .filter(b => {
+                const draft = drafts.get(this.#options.idOf(b));
+                return draft != null && !isEmptyObject(draft);
+            })
+                .map(b => deepMerge(b, drafts.get(this.#options.idOf(b))));
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "changes" }] : /* istanbul ignore next */ []));
+        this.pristine = computed(() => {
+            const baseArray = Array.from(this.#base());
+            const drafts = this.#drafts();
+            const committed = this.#committed();
+            const allIds = new Set([...drafts.keys(), ...committed.keys()]);
+            for (const id of allIds) {
+                const draft = drafts.get(id) ?? {};
+                const committedDraft = committed.get(id) ?? {};
+                const originalItem = baseArray.find(item => this.#options.idOf(item) === id);
+                const prunedDraft = originalItem ? (prunePatch(originalItem, draft) ?? {}) : draft;
+                const prunedCommitted = originalItem
+                    ? (prunePatch(originalItem, committedDraft) ?? {})
+                    : committedDraft;
+                if (!deepEquals(prunedDraft, prunedCommitted)) {
+                    return false;
+                }
+            }
+            return true;
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "pristine" }] : /* istanbul ignore next */ []));
+        this.view = computed(() => {
+            const drafts = this.#drafts();
+            return Array.from(this.#base()).map(b => {
+                const id = this.#options.idOf(b);
+                const patch = drafts.get(id);
+                if (!patch || isEmptyObject(patch)) {
+                    // No draft — return base item directly and evict any stale cache entry.
+                    this.#viewCache.delete(id);
+                    return b;
+                }
+                const cached = this.#viewCache.get(id);
+                if (cached && cached.patchRef === patch) {
+                    // Draft reference hasn't changed — return cached merged value
+                    // to avoid an unnecessary deepMerge and a new object allocation.
+                    return cached.merged;
+                }
+                const merged = deepMerge(b, patch);
+                this.#viewCache.set(id, { patchRef: patch, merged });
+                return merged;
+            });
+        }, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "view" }] : /* istanbul ignore next */ []));
+        this.#options = options;
+        this.#base = options.source();
+        let initial;
+        if (options.initial) {
+            if (options.initial() instanceof ImmutableDictionary) {
+                initial = options.initial();
+            }
+            else {
+                initial = ImmutableDictionary.create(options.initial());
+            }
+        }
+        else {
+            initial = ImmutableDictionary.create();
+        }
+        this.#committed = signal(initial, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "#committed" }] : /* istanbul ignore next */ []));
+        if (options.initial) {
+            this.#drafts.set(ImmutableDictionary.create(initial));
+        }
+    }
+    clear(id) {
+        this.#drafts.update(drafts => {
+            if (!drafts.containsKey(id))
+                return drafts;
+            const newDrafts = ImmutableDictionary.create(drafts);
+            return newDrafts.remove(id);
+        });
+    }
+    clearAll() {
+        this.#drafts.set(ImmutableDictionary.create());
+    }
+    commit() {
+        this.#committed.set(ImmutableDictionary.create(this.#drafts()));
+    }
+    dirtyCount() {
+        let count = 0;
+        for (const patch of this.#drafts().values()) {
+            if (typeof patch === "object" && patch != null && !isEmptyObject(patch)) {
+                ++count;
+            }
+        }
+        return count;
+    }
+    getCommitted() {
+        return this.#committed();
+    }
+    hasDraft(id) {
+        const patch = this.#drafts().get(id);
+        return patch != null && !isEmptyObject(patch);
+    }
+    patch(id, patch, options) {
+        this.#drafts.update(drafts => {
+            let newDrafts = ImmutableDictionary.create(drafts);
+            const prev = drafts.get(id) ?? {};
+            let next = deepMerge(prev, patch, options);
+            // Fix: use #baseMap for O(1) lookup instead of a linear scan.
+            const originalItem = this.#baseMap().get(id);
+            if (originalItem) {
+                next = prunePatch(originalItem, next) ?? {};
+            }
+            if (isEmptyObject(next)) {
+                newDrafts = newDrafts.remove(id);
+            }
+            else {
+                newDrafts = newDrafts.put(id, next);
+            }
+            return newDrafts;
+        });
+    }
+    patchMany(patchTuple, options) {
+        // Fix: prune each resulting draft against the base item for consistency
+        // with patch(), and use #baseMap for O(1) lookups.
+        const baseMap = this.#baseMap();
+        this.#drafts.update(drafts => {
+            let newDrafts = ImmutableDictionary.create(drafts);
+            for (const [id, value] of patchTuple) {
+                const prev = newDrafts.get(id) ?? {};
+                let next = deepMerge(prev, value, options);
+                const originalItem = baseMap.get(id);
+                if (originalItem) {
+                    next = prunePatch(originalItem, next) ?? {};
+                }
+                if (isEmptyObject(next)) {
+                    newDrafts = newDrafts.remove(id);
+                }
+                else {
+                    newDrafts = newDrafts.put(id, next);
+                }
+            }
+            return newDrafts;
+        });
+    }
+    patchPath(id, path, value, options) {
+        const patch = buildNested(path, value);
+        this.patch(id, patch, options);
+    }
+    reset() {
+        const empty = ImmutableDictionary.create();
+        this.#drafts.set(empty);
+        this.#committed.set(empty);
+    }
+    setDraft(id, patch) {
+        this.#drafts.update(drafts => {
+            let newDrafts = ImmutableDictionary.create(drafts);
+            newDrafts = newDrafts.put(id, patch);
+            return newDrafts;
+        });
+    }
+    setPath(id, path, value, options) {
+        // Fix: delegate to patch() so the draft is merged rather than replaced,
+        // preserving any unrelated in-progress changes.
+        const patch = buildNested(path, value);
+        this.patch(id, patch, options);
+    }
+    select(projector, equal = deepEquals) {
+        return computed(() => projector(this.view()), { equal });
+    }
+}
+const createIterablePatchStore = (options) => new IterablePatchStore(options);
+const createObjectPatchStore = (options) => new ObjectPatchStore(options);
+
+/**
+ * Calculates the percentage of a value within a given range, rounded to the specified precision.
+ * @param value The current value.
+ * @param min The minimum value.
+ * @param max The maximum value.
+ * @param precision The number of decimal places to round the percentage to.
+ * @default 2
+ * @returns The percentage of the value within the range, rounded to the specified precision.
+ */
+const getPercentage = (value, min, max, precision = 2) => {
+    if (max <= min || !isFinite(value)) {
+        return 0;
+    }
+    const raw = ((value - min) / (max - min)) * 100;
+    return Number(Math.min(100, Math.max(0, raw)).toFixed(precision));
+};
+
+function moveIndices(array, indices, offset) {
+    if (offset === 0 || indices.length === 0) {
+        return [...array];
+    }
+    // Validate indices are within bounds
+    if (indices.some(i => i < 0 || i >= array.length)) {
+        return [...array];
+    }
+    // Check if any index would go out of bounds after the move
+    for (const index of indices) {
+        const newIndex = index + offset;
+        if (newIndex < 0 || newIndex >= array.length) {
+            return [...array];
+        }
+    }
+    // Create a copy of the array
+    const result = [...array];
+    // Sort indices based on movement direction to avoid conflicts
+    const sortedIndices = [...indices].sort((a, b) => (offset > 0 ? b - a : a - b));
+    // Move each item to its new position
+    for (const index of sortedIndices) {
+        const item = result[index];
+        const newIndex = index + offset;
+        // Remove item from current position
+        result.splice(index, 1);
+        // Insert at new position
+        result.splice(newIndex, 0, item);
+    }
+    return result;
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AnyPipe, ContainsPipe, FilterChangeEvent, IterablePatchStore, ObjectPatchStore, PreventableEvent, SlicePipe, TakeFirstPipe, buildNested, createIterablePatchStore, createObjectPatchStore, deepEquals, deepMerge, getPercentage, isEmptyObject, isPlainObject, mergeInto, mergePatchInto, moveIndices, patchAt, prunePatch, setAt };
+//# sourceMappingURL=nanahoshi-mona-ui-common.mjs.map