@ibiliaze/stringman 3.18.0 → 3.19.0

package/dist/index.d.ts

@@ -141,6 +141,18 @@ export declare const isVideoUrl: (url: string) => boolean;
  * @throws Error if no endpoint returns a valid IP.
  */
 export declare const getPublicIP: () => Promise<string>;
+/**
+ * Convert an unknown value into a stable string key for deduping.
+ */
+export declare const valueKey: (v: unknown) => string;
+/**
+ * Dedupe an array by a key (dot-path supported), preserving the item type.
+ *
+ * - keepFirst=true  => first wins
+ * - keepFirst=false => last wins
+ * - keepNoKey=true  => keep items where key is missing/invalid (kept in original order, before deduped items)
+ */
+export declare const dedupeBy: <T>(arr: T[] | undefined, key: string, { keepFirst, keepNoKey }?: DedupeByOptions) => T[];
 export declare const invalidPw: (password: string, passwordLength?: number) => string | void;
 export declare const b36: (n: number) => string;
 export declare const luhn36: (s: string) => string;
@@ -170,3 +182,7 @@ export declare const crypto: {
 export declare const order: {
     createNumericOrderId: () => string;
 };
+type DedupeByOptions = {
+    keepFirst?: boolean;
+    keepNoKey?: boolean;
+};

package/dist/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.order = exports.crypto = exports.ticket = exports.luhn36 = exports.b36 = exports.invalidPw = exports.getPublicIP = exports.isVideoUrl = exports.getRandomString = exports.extractImageSrcs = exports.select = exports.query = exports.getCloudinaryPublicId = exports.dp = exports.megaTrim = exports.superTrim = void 0;
+exports.order = exports.crypto = exports.ticket = exports.luhn36 = exports.b36 = exports.invalidPw = exports.dedupeBy = exports.valueKey = exports.getPublicIP = exports.isVideoUrl = exports.getRandomString = exports.extractImageSrcs = exports.select = exports.query = exports.getCloudinaryPublicId = exports.dp = exports.megaTrim = exports.superTrim = void 0;
 __exportStar(require("./seat"), exports);
 const ticket_1 = require("./ticket");
 const order_1 = require("./order");
@@ -244,6 +244,76 @@ const getPublicIP = async () => {
     throw new Error('Public IP unavailable');
 };
 exports.getPublicIP = getPublicIP;
+/**
+ * Convert an unknown value into a stable string key for deduping.
+ */
+const valueKey = (v) => {
+    try {
+        if (v == null)
+            return '';
+        if (typeof v === 'string')
+            return v;
+        const key = String(v);
+        if (key === '[object Object]')
+            return '';
+        return key;
+    }
+    catch (e) {
+        console.error('valueKey(): failed to normalise value:', v, e);
+        return '';
+    }
+};
+exports.valueKey = valueKey;
+/**
+ * Dedupe an array by a key (dot-path supported), preserving the item type.
+ *
+ * - keepFirst=true  => first wins
+ * - keepFirst=false => last wins
+ * - keepNoKey=true  => keep items where key is missing/invalid (kept in original order, before deduped items)
+ */
+const dedupeBy = (arr = [], key, { keepFirst = true, keepNoKey = true } = {}) => {
+    try {
+        if (!Array.isArray(arr)) {
+            console.error('dedupeBy(): expected an array, got:', arr);
+            return [];
+        }
+        // Build a getter for a "dot.path" key like "user.id"
+        const getKey = (obj) => {
+            try {
+                return key.split('.').reduce((acc, k) => acc?.[k], obj);
+            }
+            catch {
+                return undefined;
+            }
+        };
+        // Map preserves insertion order, which gives stable output ordering for "first wins"
+        const map = new Map();
+        const noKey = [];
+        for (const item of arr) {
+            const raw = getKey(item);
+            const k = (0, exports.valueKey)(raw);
+            if (!k) {
+                if (keepNoKey)
+                    noKey.push(item);
+                continue;
+            }
+            if (keepFirst) {
+                if (!map.has(k))
+                    map.set(k, item);
+            }
+            else {
+                map.set(k, item); // last wins
+            }
+        }
+        const deduped = Array.from(map.values());
+        return keepNoKey ? noKey.concat(deduped) : deduped;
+    }
+    catch (e) {
+        console.error('dedupeBy(): failed:', e);
+        return Array.isArray(arr) ? arr : [];
+    }
+};
+exports.dedupeBy = dedupeBy;
 const invalidPw = (password, passwordLength = 8) => {
     try {
         if (password.length < passwordLength)

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@ibiliaze/stringman",
-  "version": "3.18.0",
+  "version": "3.19.0",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
     "build": "tsc",
     "pub": "npm publish --access public",
-    "git": "git add .; git commit -m 'changes'; git tag -a 3.18.0 -m '3.18.0'; git push origin 3.18.0; git push",
+    "git": "git add .; git commit -m 'changes'; git tag -a 3.19.0 -m '3.19.0'; git push origin 3.19.0; git push",
     "push": "npm run build; npm run git; npm run pub"
   },
   "author": "Ibi Hasanli",

package/src/index.ts

@@ -230,6 +230,79 @@ export const getPublicIP = async (): Promise<string> => {
   throw new Error('Public IP unavailable');
 };
 
+/**
+ * Convert an unknown value into a stable string key for deduping.
+ */
+export const valueKey = (v: unknown): string => {
+  try {
+    if (v == null) return '';
+    if (typeof v === 'string') return v;
+
+    const key = String(v);
+    if (key === '[object Object]') return '';
+
+    return key;
+  } catch (e) {
+    console.error('valueKey(): failed to normalise value:', v, e);
+    return '';
+  }
+};
+
+/**
+ * Dedupe an array by a key (dot-path supported), preserving the item type.
+ *
+ * - keepFirst=true  => first wins
+ * - keepFirst=false => last wins
+ * - keepNoKey=true  => keep items where key is missing/invalid (kept in original order, before deduped items)
+ */
+export const dedupeBy = <T>(
+  arr: T[] = [],
+  key: string,
+  { keepFirst = true, keepNoKey = true }: DedupeByOptions = {}
+): T[] => {
+  try {
+    if (!Array.isArray(arr)) {
+      console.error('dedupeBy(): expected an array, got:', arr);
+      return [];
+    }
+
+    // Build a getter for a "dot.path" key like "user.id"
+    const getKey = (obj: any): unknown => {
+      try {
+        return key.split('.').reduce((acc, k) => acc?.[k], obj);
+      } catch {
+        return undefined;
+      }
+    };
+
+    // Map preserves insertion order, which gives stable output ordering for "first wins"
+    const map = new Map<string, T>();
+    const noKey: T[] = [];
+
+    for (const item of arr) {
+      const raw = getKey(item);
+      const k = valueKey(raw);
+
+      if (!k) {
+        if (keepNoKey) noKey.push(item);
+        continue;
+      }
+
+      if (keepFirst) {
+        if (!map.has(k)) map.set(k, item);
+      } else {
+        map.set(k, item); // last wins
+      }
+    }
+
+    const deduped = Array.from(map.values());
+    return keepNoKey ? noKey.concat(deduped) : deduped;
+  } catch (e) {
+    console.error('dedupeBy(): failed:', e);
+    return Array.isArray(arr) ? arr : [];
+  }
+};
+
 export const invalidPw = (password: string, passwordLength: number = 8): string | void => {
   try {
     if (password.length < passwordLength) return `Password must be at least ${passwordLength} characters`;
@@ -292,3 +365,8 @@ export const crypto = {
 };
 
 export const order = { createNumericOrderId };
+
+type DedupeByOptions = {
+  keepFirst?: boolean;
+  keepNoKey?: boolean;
+};