@ibiliaze/stringman 3.17.0 → 3.19.0

package/dist/crypto.d.ts

@@ -0,0 +1,2 @@
+export declare function encryptString(plainText: string, password: string): Promise<string>;
+export declare function decryptString(cipherTextB64: string, password: string): Promise<string>;

package/dist/crypto.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encryptString = encryptString;
+exports.decryptString = decryptString;
+const enc = new TextEncoder();
+const dec = new TextDecoder();
+async function getKeyFromPassword(password, salt) {
+    const keyMaterial = await crypto.subtle.importKey('raw', enc.encode(password), 'PBKDF2', false, ['deriveKey']);
+    return crypto.subtle.deriveKey({
+        name: 'PBKDF2',
+        salt, // ArrayBuffer is valid BufferSource
+        iterations: 100_000,
+        hash: 'SHA-256',
+    }, keyMaterial, {
+        name: 'AES-GCM',
+        length: 256,
+    }, false, ['encrypt', 'decrypt']);
+}
+async function encryptString(plainText, password) {
+    const saltBytes = crypto.getRandomValues(new Uint8Array(16));
+    const iv = crypto.getRandomValues(new Uint8Array(12));
+    const key = await getKeyFromPassword(password, saltBytes.buffer);
+    const cipherBuffer = await crypto.subtle.encrypt({ name: 'AES-GCM', iv }, key, enc.encode(plainText));
+    const cipherBytes = new Uint8Array(cipherBuffer);
+    const combined = new Uint8Array(saltBytes.length + iv.length + cipherBytes.length);
+    combined.set(saltBytes, 0);
+    combined.set(iv, saltBytes.length);
+    combined.set(cipherBytes, saltBytes.length + iv.length);
+    return bufferToBase64(combined.buffer);
+}
+async function decryptString(cipherTextB64, password) {
+    const combined = new Uint8Array(base64ToBuffer(cipherTextB64));
+    const saltBytes = combined.slice(0, 16);
+    const iv = combined.slice(16, 28);
+    const cipherBytes = combined.slice(28);
+    // 👇 again, .buffer
+    const key = await getKeyFromPassword(password, saltBytes.buffer);
+    const plainBuffer = await crypto.subtle.decrypt({ name: 'AES-GCM', iv }, key, cipherBytes);
+    return dec.decode(plainBuffer);
+}
+/* base64 helpers stay the same */
+function bufferToBase64(buf) {
+    const bytes = new Uint8Array(buf);
+    let binary = '';
+    for (let i = 0; i < bytes.length; i++)
+        binary += String.fromCharCode(bytes[i]);
+    return btoa(binary);
+}
+function base64ToBuffer(b64) {
+    const binary = atob(b64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++)
+        bytes[i] = binary.charCodeAt(i);
+    return bytes.buffer;
+}

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export * from './seat';
 import { fishyMatchesAll } from './ticket';
+import { decryptString, encryptString } from './crypto';
 /**
  * Clean up extra whitespace in a string.
  *
@@ -140,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;
@@ -162,6 +175,14 @@ export declare const ticket: {
     validateTicketCode: (code: string) => boolean;
     fishyMatchesAll: typeof fishyMatchesAll;
 };
+export declare const crypto: {
+    encryptString: typeof encryptString;
+    decryptString: typeof decryptString;
+};
 export declare const order: {
     createNumericOrderId: () => string;
 };
+type DedupeByOptions = {
+    keepFirst?: boolean;
+    keepNoKey?: boolean;
+};

package/dist/index.js

@@ -14,10 +14,11 @@ 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.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");
+const crypto_1 = require("./crypto");
 /**
  * Clean up extra whitespace in a string.
  *
@@ -243,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)
@@ -308,4 +379,8 @@ exports.ticket = {
     validateTicketCode: ticket_1.validateTicketCode,
     fishyMatchesAll: ticket_1.fishyMatchesAll,
 };
+exports.crypto = {
+    encryptString: crypto_1.encryptString,
+    decryptString: crypto_1.decryptString,
+};
 exports.order = { createNumericOrderId: order_1.createNumericOrderId };

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@ibiliaze/stringman",
-  "version": "3.17.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.17.0 -m '3.17.0'; git push origin 3.17.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/crypto.ts

@@ -0,0 +1,69 @@
+const enc = new TextEncoder();
+const dec = new TextDecoder();
+
+async function getKeyFromPassword(password: string, salt: ArrayBuffer): Promise<CryptoKey> {
+  const keyMaterial = await crypto.subtle.importKey('raw', enc.encode(password), 'PBKDF2', false, ['deriveKey']);
+
+  return crypto.subtle.deriveKey(
+    {
+      name: 'PBKDF2',
+      salt, // ArrayBuffer is valid BufferSource
+      iterations: 100_000,
+      hash: 'SHA-256',
+    },
+    keyMaterial,
+    {
+      name: 'AES-GCM',
+      length: 256,
+    },
+    false,
+    ['encrypt', 'decrypt']
+  );
+}
+
+export async function encryptString(plainText: string, password: string): Promise<string> {
+  const saltBytes = crypto.getRandomValues(new Uint8Array(16));
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+
+  const key = await getKeyFromPassword(password, saltBytes.buffer);
+
+  const cipherBuffer = await crypto.subtle.encrypt({ name: 'AES-GCM', iv }, key, enc.encode(plainText));
+
+  const cipherBytes = new Uint8Array(cipherBuffer);
+  const combined = new Uint8Array(saltBytes.length + iv.length + cipherBytes.length);
+  combined.set(saltBytes, 0);
+  combined.set(iv, saltBytes.length);
+  combined.set(cipherBytes, saltBytes.length + iv.length);
+
+  return bufferToBase64(combined.buffer);
+}
+
+export async function decryptString(cipherTextB64: string, password: string): Promise<string> {
+  const combined = new Uint8Array(base64ToBuffer(cipherTextB64));
+
+  const saltBytes = combined.slice(0, 16);
+  const iv = combined.slice(16, 28);
+  const cipherBytes = combined.slice(28);
+
+  // 👇 again, .buffer
+  const key = await getKeyFromPassword(password, saltBytes.buffer);
+
+  const plainBuffer = await crypto.subtle.decrypt({ name: 'AES-GCM', iv }, key, cipherBytes);
+
+  return dec.decode(plainBuffer);
+}
+
+/* base64 helpers stay the same */
+function bufferToBase64(buf: ArrayBuffer): string {
+  const bytes = new Uint8Array(buf);
+  let binary = '';
+  for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
+  return btoa(binary);
+}
+
+function base64ToBuffer(b64: string): ArrayBuffer {
+  const binary = atob(b64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  return bytes.buffer;
+}

package/src/index.ts

@@ -1,6 +1,7 @@
 export * from './seat';
 import { buildTicketCode, getTicketId, validateTicketCode, fishyMatchesAll } from './ticket';
 import { createNumericOrderId } from './order';
+import { decryptString, encryptString } from './crypto';
 
 /**
  * Clean up extra whitespace in a string.
@@ -229,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`;
@@ -285,4 +359,14 @@ export const ticket = {
   fishyMatchesAll,
 };
 
+export const crypto = {
+  encryptString,
+  decryptString,
+};
+
 export const order = { createNumericOrderId };
+
+type DedupeByOptions = {
+  keepFirst?: boolean;
+  keepNoKey?: boolean;
+};