ts-data-forge 1.0.0 → 1.0.1

package/dist/collections/iset-mapped.mjs

@@ -0,0 +1,522 @@
+import '../number/branded-types/finite-number.mjs';
+import '../number/branded-types/int.mjs';
+import '../number/branded-types/int16.mjs';
+import '../number/branded-types/int32.mjs';
+import '../number/branded-types/non-negative-finite-number.mjs';
+import '../number/branded-types/non-negative-int16.mjs';
+import '../number/branded-types/non-negative-int32.mjs';
+import '../number/branded-types/non-zero-finite-number.mjs';
+import '../number/branded-types/non-zero-int.mjs';
+import '../number/branded-types/non-zero-int16.mjs';
+import '../number/branded-types/non-zero-int32.mjs';
+import '../number/branded-types/non-zero-safe-int.mjs';
+import '../number/branded-types/non-zero-uint16.mjs';
+import '../number/branded-types/non-zero-uint32.mjs';
+import '../number/branded-types/positive-finite-number.mjs';
+import '../number/branded-types/positive-int.mjs';
+import '../number/branded-types/positive-int16.mjs';
+import '../number/branded-types/positive-int32.mjs';
+import '../number/branded-types/positive-safe-int.mjs';
+import '../number/branded-types/positive-uint16.mjs';
+import '../number/branded-types/positive-uint32.mjs';
+import '../number/branded-types/safe-int.mjs';
+import '../number/branded-types/safe-uint.mjs';
+import '../number/branded-types/uint.mjs';
+import '../number/branded-types/uint16.mjs';
+import { asUint32 } from '../number/branded-types/uint32.mjs';
+import '../number/enum/int8.mjs';
+import '../number/enum/uint8.mjs';
+import '../number/num.mjs';
+import '../number/refined-number-utils.mjs';
+
+/**
+ * Provides utility functions for ISetMapped.
+ */
+var ISetMapped;
+(function (ISetMapped) {
+    /**
+     * Creates a new ISetMapped instance with custom element transformation functions.
+     *
+     * This factory function creates an immutable set that can use complex objects as elements
+     * by providing bidirectional transformation functions. The `toKey` function converts
+     * your custom element type to a primitive type that can be efficiently stored, while
+     * `fromKey` reconstructs the original element type for iteration and access.
+     *
+     * **Performance:** O(n) where n is the number of elements in the iterable.
+     *
+     * @template K The type of the custom elements.
+     * @template KM The type of the mapped primitive keys.
+     * @param iterable An iterable of elements using the custom element type.
+     * @param toKey A function that converts a custom element `K` to a primitive key `KM`.
+     *              This function must be deterministic and produce unique values for unique elements.
+     * @param fromKey A function that converts a primitive key `KM` back to the custom element `K`.
+     *                This should be the inverse of `toKey`.
+     * @returns A new ISetMapped instance containing all unique elements from the iterable.
+     *
+     * @example
+     * ```typescript
+     * // Example 1: Product catalog with SKU-based identity
+     * type Product = { sku: string; name: string; price: number; category: string };
+     *
+     * const productToKey = (product: Product): string => product.sku;
+     * const keyToProduct = (sku: string): Product => {
+     *   // In practice, this might fetch from a product service or cache
+     *   return {
+     *     sku,
+     *     name: `Product ${sku}`,
+     *     price: 0,
+     *     category: "unknown"
+     *   };
+     * };
+     *
+     * const productSet = ISetMapped.create<Product, string>(
+     *   [
+     *     { sku: "LAPTOP-001", name: "Gaming Laptop", price: 1299, category: "electronics" },
+     *     { sku: "MOUSE-002", name: "Wireless Mouse", price: 49, category: "accessories" },
+     *     { sku: "LAPTOP-001", name: "Gaming Laptop", price: 1299, category: "electronics" } // Duplicate SKU
+     *   ],
+     *   productToKey,
+     *   keyToProduct
+     * );
+     *
+     * console.log(productSet.size); // Output: 2 (duplicate removed)
+     * console.log(productSet.has({ sku: "LAPTOP-001", name: "Gaming Laptop", price: 1299, category: "electronics" })); // true
+     *
+     * // Example 2: Geographic locations with coordinate-based identity
+     * type Location = { name: string; lat: number; lng: number; type: string };
+     *
+     * const locationToKey = (loc: Location): string => `${loc.lat.toFixed(6)},${loc.lng.toFixed(6)}`;
+     * const keyToLocation = (key: string): Location => {
+     *   const [latStr, lngStr] = key.split(',');
+     *   return {
+     *     name: "Unknown Location",
+     *     lat: parseFloat(latStr),
+     *     lng: parseFloat(lngStr),
+     *     type: "point"
+     *   };
+     * };
+     *
+     * const locationSet = ISetMapped.create<Location, string>(
+     *   [
+     *     { name: "Statue of Liberty", lat: 40.689247, lng: -74.044502, type: "monument" },
+     *     { name: "Empire State Building", lat: 40.748817, lng: -73.985428, type: "building" }
+     *   ],
+     *   locationToKey,
+     *   keyToLocation
+     * );
+     *
+     * // Example 3: User entities with multi-part identity
+     * type User = { id: number; tenant: string; email: string; active: boolean };
+     *
+     * const userToKey = (user: User): string => `${user.tenant}:${user.id}`;
+     * const keyToUser = (key: string): User => {
+     *   const [tenant, idStr] = key.split(':');
+     *   return {
+     *     id: Number(idStr),
+     *     tenant,
+     *     email: `user${idStr}@${tenant}.com`,
+     *     active: true
+     *   };
+     * };
+     *
+     * const userSet = ISetMapped.create<User, string>(
+     *   [],
+     *   userToKey,
+     *   keyToUser
+     * )
+     * .add({ id: 1, tenant: "acme", email: "alice@acme.com", active: true })
+     * .add({ id: 2, tenant: "acme", email: "bob@acme.com", active: false });
+     *
+     * console.log(userSet.size); // Output: 2
+     *
+     * // Example 4: Empty set with type specification
+     * const emptyProductSet = ISetMapped.create<Product, string>(
+     *   [],
+     *   productToKey,
+     *   keyToProduct
+     * );
+     * console.log(emptyProductSet.isEmpty); // Output: true
+     * ```
+     */
+    ISetMapped.create = (iterable, toKey, fromKey) => new ISetMappedClass(iterable, toKey, fromKey);
+    /**
+     * Checks if two ISetMapped instances are structurally equal.
+     *
+     * Two ISetMapped instances are considered equal if they have the same size and contain
+     * exactly the same elements. The comparison is performed on the underlying mapped keys,
+     * so the transformation functions themselves don't need to be identical. Elements are
+     * compared based on their mapped key representations.
+     *
+     * **Performance:** O(n) where n is the size of the smaller set.
+     *
+     * @template K The type of the custom elements.
+     * @template KM The type of the mapped primitive keys.
+     * @param a The first ISetMapped instance to compare.
+     * @param b The second ISetMapped instance to compare.
+     * @returns `true` if the sets contain exactly the same elements, `false` otherwise.
+     *
+     * @example
+     * ```typescript
+     * // Example with coordinate-based elements
+     * type Point = { x: number; y: number; label?: string };
+     * const pointToKey = (p: Point): string => `${p.x},${p.y}`;
+     * const keyToPoint = (s: string): Point => {
+     *   const [x, y] = s.split(',').map(Number);
+     *   return { x, y };
+     * };
+     *
+     * const set1 = ISetMapped.create<Point, string>(
+     *   [{ x: 1, y: 2, label: "A" }, { x: 3, y: 4, label: "B" }],
+     *   pointToKey,
+     *   keyToPoint
+     * );
+     *
+     * const set2 = ISetMapped.create<Point, string>(
+     *   [{ x: 3, y: 4, label: "Different" }, { x: 1, y: 2, label: "Labels" }], // Order doesn't matter
+     *   pointToKey,
+     *   keyToPoint
+     * );
+     *
+     * const set3 = ISetMapped.create<Point, string>(
+     *   [{ x: 1, y: 2 }, { x: 5, y: 6 }], // Different point
+     *   pointToKey,
+     *   keyToPoint
+     * );
+     *
+     * console.log(ISetMapped.equal(set1, set2)); // true (same coordinates, labels don't affect equality)
+     * console.log(ISetMapped.equal(set1, set3)); // false (different coordinates)
+     *
+     * // Example with user entities
+     * type User = { id: number; department: string; name: string };
+     * const userToKey = (u: User): string => `${u.department}:${u.id}`;
+     * const keyToUser = (k: string): User => {
+     *   const [department, idStr] = k.split(':');
+     *   return { id: Number(idStr), department, name: "" };
+     * };
+     *
+     * const users1 = ISetMapped.create<User, string>(
+     *   [
+     *     { id: 1, department: "eng", name: "Alice" },
+     *     { id: 2, department: "sales", name: "Bob" }
+     *   ],
+     *   userToKey,
+     *   keyToUser
+     * );
+     *
+     * const users2 = ISetMapped.create<User, string>(
+     *   [
+     *     { id: 2, department: "sales", name: "Robert" }, // Different name, same identity
+     *     { id: 1, department: "eng", name: "Alicia" }    // Different name, same identity
+     *   ],
+     *   userToKey,
+     *   keyToUser
+     * );
+     *
+     * console.log(ISetMapped.equal(users1, users2)); // true (same department:id combinations)
+     *
+     * // Empty sets
+     * const empty1 = ISetMapped.create<Point, string>([], pointToKey, keyToPoint);
+     * const empty2 = ISetMapped.create<Point, string>([], pointToKey, keyToPoint);
+     * console.log(ISetMapped.equal(empty1, empty2)); // true
+     *
+     * // Sets with different transformation functions but same logical content
+     * const alternativePointToKey = (p: Point): string => `(${p.x},${p.y})`; // Different format
+     * const alternativeKeyToPoint = (s: string): Point => {
+     *   const match = s.match(/\((\d+),(\d+)\)/)!;
+     *   return { x: Number(match[1]), y: Number(match[2]) };
+     * };
+     *
+     * const set4 = ISetMapped.create<Point, string>(
+     *   [{ x: 1, y: 2 }, { x: 3, y: 4 }],
+     *   alternativePointToKey,
+     *   alternativeKeyToPoint
+     * );
+     *
+     * // This would be false because the underlying mapped keys are different
+     * console.log(ISetMapped.equal(set1, set4)); // false
+     * ```
+     */
+    ISetMapped.equal = (a, b) => a.size === b.size && a.every((e) => b.has(e));
+    /**
+     * Computes the difference between two ISetMapped instances.
+     * @template K The type of the elements.
+     * @template KM The type of the mapped keys.
+     * @param oldSet The original set.
+     * @param newSet The new set.
+     * @returns An object containing sets of added and deleted elements.
+     * @example
+     * ```typescript
+     * type Tag = { name: string };
+     * const tagToKey = (t: Tag): string => t.name;
+     * const keyToTag = (name: string): Tag => ({ name });
+     *
+     * const oldTags = ISetMapped.create<Tag, string>(
+     *   [{ name: "typescript" }, { name: "javascript" }],
+     *   tagToKey,
+     *   keyToTag
+     * );
+     * const newTags = ISetMapped.create<Tag, string>(
+     *   [{ name: "javascript" }, { name: "react" }, { name: "nextjs" }],
+     *   tagToKey,
+     *   keyToTag
+     * );
+     *
+     * const diffResult = ISetMapped.diff(oldTags, newTags);
+     *
+     * console.log("Deleted tags:", diffResult.deleted.toArray().map(t => t.name));
+     * // Output: Deleted tags: ["typescript"]
+     *
+     * console.log("Added tags:", diffResult.added.toArray().map(t => t.name));
+     * // Output: Added tags: ["react", "nextjs"]
+     * ```
+     */
+    ISetMapped.diff = (oldSet, newSet) => ({
+        deleted: oldSet.subtract(newSet),
+        added: newSet.subtract(oldSet),
+    });
+    /**
+     * Computes the intersection of two ISetMapped instances.
+     * @template K The type of the elements.
+     * @template KM The type of the mapped keys.
+     * @param a The first set.
+     * @param b The second set.
+     * @returns A new ISetMapped instance representing the intersection.
+     * @example
+     * ```typescript
+     * type Permission = { id: string };
+     * const permToKey = (p: Permission): string => p.id;
+     * const keyToPerm = (id: string): Permission => ({ id });
+     *
+     * const userPermissions = ISetMapped.create<Permission, string>(
+     *   [{ id: "read" }, { id: "write" }, { id: "delete" }],
+     *   permToKey,
+     *   keyToPerm
+     * );
+     * const rolePermissions = ISetMapped.create<Permission, string>(
+     *   [{ id: "read" }, { id: "comment" }, { id: "write" }],
+     *   permToKey,
+     *   keyToPerm
+     * );
+     *
+     * const commonPermissions = ISetMapped.intersection(userPermissions, rolePermissions);
+     * console.log(commonPermissions.toArray().map(p => p.id)); // Output: ["read", "write"]
+     * ```
+     */
+    ISetMapped.intersection = (a, b) => a.intersect(b);
+    /**
+     * Computes the union of two ISetMapped instances.
+     * @template K The type of the elements.
+     * @template KM The type of the mapped keys.
+     * @param a The first set.
+     * @param b The second set.
+     * @returns A new ISetMapped instance representing the union.
+     * @example
+     * ```typescript
+     * type FeatureFlag = { flagName: string };
+     * const flagToKey = (f: FeatureFlag): string => f.flagName;
+     * const keyToFlag = (name: string): FeatureFlag => ({ flagName: name });
+     *
+     * const setA = ISetMapped.create<FeatureFlag, string>(
+     *   [{ flagName: "newUI" }, { flagName: "betaFeature" }],
+     *   flagToKey,
+     *   keyToFlag
+     * );
+     * const setB = ISetMapped.create<FeatureFlag, string>(
+     *   [{ flagName: "betaFeature" }, { flagName: "darkMode" }],
+     *   flagToKey,
+     *   keyToFlag
+     * );
+     *
+     * const combinedFlags = ISetMapped.union(setA, setB);
+     * // The order might vary as sets are unordered internally.
+     * console.log(combinedFlags.toArray().map(f => f.flagName).sort());
+     * // Output: ["betaFeature", "darkMode", "newUI"]
+     * ```
+     */
+    ISetMapped.union = (a, b) => a.union(b);
+})(ISetMapped || (ISetMapped = {}));
+/**
+ * Internal class implementation for ISetMapped providing immutable set operations with element transformation.
+ *
+ * This class implements the ISetMapped interface by maintaining a JavaScript Set with primitive keys
+ * internally while exposing an API that works with custom element types. The transformation between
+ * custom and primitive elements is handled transparently through the provided `toKey` and `fromKey` functions.
+ *
+ * **Implementation Details:**
+ * - Uses ReadonlySet<KM> internally where KM is the primitive key type
+ * - Stores transformation functions for bidirectional element conversion
+ * - Implements copy-on-write semantics for efficiency
+ * - Provides optional debug messaging for development
+ *
+ * @template K The type of the custom elements.
+ * @template KM The type of the mapped primitive keys.
+ * @implements ISetMapped
+ * @implements Iterable
+ * @internal This class should not be used directly. Use ISetMapped.create() instead.
+ */
+class ISetMappedClass {
+    #set;
+    #toKey;
+    #fromKey;
+    #showNotFoundMessage;
+    /**
+     * Constructs an ISetMappedClass instance with custom element transformation.
+     *
+     * @param iterable An iterable of elements using the custom element type K.
+     * @param toKey A function that converts a custom element K to a primitive key KM.
+     *              Must be deterministic and produce unique values for unique elements.
+     * @param fromKey A function that converts a primitive key KM back to the custom element K.
+     *                Should be the inverse of the toKey function.
+     * @param showNotFoundMessage Whether to log warning messages when operations
+     *                           are performed on non-existent elements. Useful for debugging.
+     *                           Defaults to false for production use.
+     * @internal Use ISetMapped.create() instead of calling this constructor directly.
+     */
+    constructor(iterable, toKey, fromKey, showNotFoundMessage = false) {
+        this.#set = new Set(Array.from(iterable, toKey));
+        this.#toKey = toKey;
+        this.#fromKey = fromKey;
+        this.#showNotFoundMessage = showNotFoundMessage;
+    }
+    /** @inheritdoc */
+    get size() {
+        return asUint32(this.#set.size);
+    }
+    /** @inheritdoc */
+    get isEmpty() {
+        return this.size === 0;
+    }
+    /** @inheritdoc */
+    has(key) {
+        return this.#set.has(this.#toKey(key));
+    }
+    /** @inheritdoc */
+    every(predicate) {
+        for (const key of this.values()) {
+            if (!predicate(key))
+                return false;
+        }
+        return true;
+    }
+    /** @inheritdoc */
+    some(predicate) {
+        for (const key of this.values()) {
+            if (predicate(key))
+                return true;
+        }
+        return false;
+    }
+    /** @inheritdoc */
+    add(key) {
+        if (this.has(key))
+            return this;
+        return ISetMapped.create([...this.#set, this.#toKey(key)].map(this.#fromKey), this.#toKey, this.#fromKey);
+    }
+    /** @inheritdoc */
+    delete(key) {
+        if (!this.has(key)) {
+            if (this.#showNotFoundMessage) {
+                console.warn(`ISetMapped.delete: key not found: ${String(this.#toKey(key))}`);
+            }
+            return this;
+        }
+        const keyMapped = this.#toKey(key);
+        return ISetMapped.create(Array.from(this.#set)
+            .filter((k) => !Object.is(k, keyMapped))
+            .map(this.#fromKey), this.#toKey, this.#fromKey);
+    }
+    /** @inheritdoc */
+    withMutations(actions) {
+        const mut_result = new Set(this.#set);
+        for (const action of actions) {
+            const key = this.#toKey(action.key);
+            switch (action.type) {
+                case 'delete':
+                    mut_result.delete(key);
+                    break;
+                case 'add':
+                    mut_result.add(key);
+                    break;
+            }
+        }
+        return ISetMapped.create(Array.from(mut_result, this.#fromKey), this.#toKey, this.#fromKey);
+    }
+    /** @inheritdoc */
+    map(mapFn) {
+        return ISetMapped.create(this.toArray().map(mapFn), this.#toKey, this.#fromKey);
+    }
+    /** @inheritdoc */
+    filter(predicate) {
+        return ISetMapped.create(this.toArray().filter(predicate), this.#toKey, this.#fromKey);
+    }
+    /** @inheritdoc */
+    filterNot(predicate) {
+        return ISetMapped.create(this.toArray().filter((k) => !predicate(k)), this.#toKey, this.#fromKey);
+    }
+    /** @inheritdoc */
+    forEach(callbackfn) {
+        for (const km of this.#set) {
+            callbackfn(this.#fromKey(km));
+        }
+    }
+    /** @inheritdoc */
+    isSubsetOf(set) {
+        return this.every((k) => set.has(k));
+    }
+    /** @inheritdoc */
+    isSupersetOf(set) {
+        return set.every((k) => this.has(k));
+    }
+    /** @inheritdoc */
+    subtract(set) {
+        return ISetMapped.create(this.toArray().filter((k) => !set.has(k)), this.#toKey, this.#fromKey);
+    }
+    /** @inheritdoc */
+    intersect(set) {
+        return ISetMapped.create(this.toArray().filter((k) => set.has(k)), this.#toKey, this.#fromKey);
+    }
+    /** @inheritdoc */
+    union(set) {
+        return ISetMapped.create([...this.values(), ...set.values()], this.#toKey, this.#fromKey);
+    }
+    /**
+     * @inheritdoc
+     */
+    *[Symbol.iterator]() {
+        for (const k of this.keys()) {
+            yield k;
+        }
+    }
+    /** @inheritdoc */
+    *keys() {
+        for (const km of this.#set.keys()) {
+            yield this.#fromKey(km);
+        }
+    }
+    /** @inheritdoc */
+    *values() {
+        for (const km of this.#set.keys()) {
+            // JavaScript Set's values() is an alias for keys()
+            yield this.#fromKey(km);
+        }
+    }
+    /** @inheritdoc */
+    *entries() {
+        for (const km of this.#set.keys()) {
+            // JavaScript Set's entries() yields [value, value]
+            const a = this.#fromKey(km);
+            yield [a, a];
+        }
+    }
+    /** @inheritdoc */
+    toArray() {
+        return Array.from(this.values());
+    }
+    /** @inheritdoc */
+    toRawSet() {
+        return this.#set;
+    }
+}
+
+export { ISetMapped };
+//# sourceMappingURL=iset-mapped.mjs.map

package/dist/collections/iset-mapped.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"iset-mapped.mjs","sources":["../../src/collections/iset-mapped.mts"],"sourcesContent":[null],"names":[],"mappings":"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"}