@fluixi/utils 1.0.0-alpha.100

package/dist/lib/object/object.cjs

@@ -0,0 +1,280 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/object/object.ts
+var object_exports = {};
+__export(object_exports, {
+  clean: () => clean,
+  deepFreeze: () => deepFreeze,
+  defaults: () => defaults,
+  filter: () => filter,
+  fromQueryString: () => fromQueryString,
+  groupBy: () => groupBy,
+  invert: () => invert,
+  isNonNullObject: () => isNonNullObject,
+  size: () => size,
+  toQueryString: () => toQueryString,
+  transform: () => transform
+});
+module.exports = __toCommonJS(object_exports);
+
+// src/lib/object/utils.ts
+var isObject = (value) => {
+  if (value == null) return false;
+  if (Array.isArray(value)) return false;
+  if (typeof value === "function") return false;
+  if (value instanceof Date) return false;
+  if (value instanceof RegExp) return false;
+  if (value instanceof Map) return false;
+  if (value instanceof Set) return false;
+  if (value instanceof Error) return false;
+  return typeof value === "object";
+};
+
+// src/lib/object/clone.ts
+var deepClone = (obj, skipKeys) => {
+  if (obj == null || typeof obj !== "object") {
+    return obj;
+  }
+  if (obj instanceof Date) {
+    return new Date(obj.getTime());
+  }
+  if (obj instanceof RegExp) {
+    return new RegExp(obj.source, obj.flags);
+  }
+  if (obj instanceof Map) {
+    const clone = /* @__PURE__ */ new Map();
+    obj.forEach((value, key) => {
+      if (!skipKeys || !skipKeys.some((k) => k.toString() === key.toString())) {
+        clone.set(key, deepClone(value));
+      }
+    });
+    return clone;
+  }
+  if (obj instanceof Set) {
+    const clone = /* @__PURE__ */ new Set();
+    obj.forEach((value) => {
+      clone.add(deepClone(value));
+    });
+    return clone;
+  }
+  if (Array.isArray(obj)) {
+    return Array.from(obj).map((item) => deepClone(item));
+  }
+  if (isObject(obj)) {
+    const clone = {};
+    for (const key in obj) {
+      if (Object.prototype.hasOwnProperty.call(obj, key)) {
+        if (!skipKeys || !skipKeys.some((k) => k.toString() === key.toString())) {
+          clone[key] = deepClone(obj[key]);
+        }
+      }
+    }
+    const symbols = Object.getOwnPropertySymbols(obj);
+    for (const symbol of symbols) {
+      if (!skipKeys || !skipKeys.some((s) => s.toString() === symbol.toString())) {
+        clone[symbol] = deepClone(obj[symbol]);
+      }
+    }
+    return clone;
+  }
+  return obj;
+};
+
+// src/lib/object/object.ts
+var invert = (obj, deep = false) => {
+  if (Array.isArray(obj)) {
+    return obj.map((item) => invert(item, deep));
+  }
+  if (!isObject(obj)) {
+    return {};
+  }
+  const result = {};
+  for (const key in obj) {
+    let value = obj[key];
+    if (typeof value === "string" || typeof value === "number" || typeof value === "symbol") {
+      result[value] = key;
+    } else if (isObject(value)) {
+      if (deep) {
+        result[key] = invert(value, deep);
+      }
+    } else if (Array.isArray(value)) {
+      if (deep) {
+        result[key] = value.map((item) => invert(item, deep));
+      }
+    }
+  }
+  return result;
+};
+var filter = (obj, predicate) => {
+  if (Array.isArray(obj)) {
+    return obj.filter(predicate);
+  }
+  if (!isObject(obj)) {
+    return {};
+  }
+  const result = {};
+  for (const key in obj) {
+    if (predicate(obj[key], key)) {
+      result[key] = obj[key];
+    }
+  }
+  return result;
+};
+var clean = (obj, deep = false) => {
+  if (!isObject(obj)) {
+    return {};
+  }
+  const result = {};
+  for (const key in obj) {
+    const value = obj[key];
+    if (value != null) {
+      if (deep && isObject(value)) {
+        const cleaned = clean(value, true);
+        if (Object.keys(cleaned).length > 0) {
+          result[key] = cleaned;
+        }
+      } else {
+        result[key] = value;
+      }
+    }
+  }
+  return result;
+};
+var defaults = (current, overrides) => {
+  if (Array.isArray(current)) {
+    if (Array.isArray(overrides)) {
+      return [...current, ...overrides];
+    }
+    return [...current, overrides];
+  }
+  const result = deepClone(current);
+  for (const key in overrides) {
+    if (result[key] === void 0) {
+      result[key] = overrides[key];
+    }
+  }
+  return result;
+};
+var size = (obj) => {
+  if (!isObject(obj)) {
+    return 0;
+  }
+  return Object.keys(obj).length;
+};
+var transform = (obj, transformer) => {
+  if (Array.isArray(obj)) {
+    return obj.map(transformer);
+  }
+  if (!isObject(obj)) {
+    return {};
+  }
+  const result = {};
+  for (const key in obj) {
+    const [newKey, newValue] = transformer(key, obj[key]);
+    result[newKey] = newValue;
+  }
+  return result;
+};
+var groupBy = (array, key) => {
+  if (!Array.isArray(array)) {
+    return {};
+  }
+  return array.reduce((groups, item) => {
+    const groupKey = item[key];
+    if (groupKey == null) {
+      return groups;
+    }
+    const keyStr = String(groupKey);
+    if (!groups[keyStr]) {
+      groups[keyStr] = [];
+    }
+    groups[keyStr].push(item);
+    return groups;
+  }, {});
+};
+var toQueryString = (obj) => {
+  if (!isObject(obj)) {
+    return "";
+  }
+  const params = [];
+  const addParam = (key, value) => {
+    if (value == null) return;
+    if (Array.isArray(value)) {
+      value.forEach((item) => {
+        params.push(`${encodeURIComponent(key)}=${encodeURIComponent(item)}`);
+      });
+    } else {
+      params.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
+    }
+  };
+  for (const key in obj) {
+    addParam(key, obj[key]);
+  }
+  return params.join("&");
+};
+var fromQueryString = (queryString) => {
+  if (!queryString || typeof queryString !== "string") {
+    return {};
+  }
+  const str = queryString.startsWith("?") ? queryString.slice(1) : queryString;
+  if (!str) {
+    return {};
+  }
+  const result = {};
+  const pairs = str.split("&");
+  for (const pair of pairs) {
+    const [key, value] = pair.split("=").map(decodeURIComponent);
+    if (key) {
+      if (key in result) {
+        if (Array.isArray(result[key])) {
+          result[key].push(value || "");
+        } else {
+          result[key] = [result[key], value || ""];
+        }
+      } else {
+        result[key] = value || "";
+      }
+    }
+  }
+  return result;
+};
+var deepFreeze = (obj) => {
+  if (obj == null || typeof obj !== "object") {
+    return obj;
+  }
+  Object.freeze(obj);
+  for (const key in obj) {
+    const value = obj[key];
+    if (value != null && typeof value === "object") {
+      deepFreeze(value);
+    }
+  }
+  const symbols = Object.getOwnPropertySymbols(obj);
+  for (const symbol of symbols) {
+    const value = obj[symbol];
+    if (value != null && typeof value === "object") {
+      deepFreeze(value);
+    }
+  }
+  return obj;
+};
+var isNonNullObject = (value) => {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+};

package/dist/lib/object/object.d.ts

@@ -0,0 +1,128 @@
+import type { AnyObject, DeepReadonly, RecordObject } from './types.js';
+/**
+ * Inverts an object (swaps keys and values)
+ * @param obj - Source object
+ * @returns Inverted object
+ * @example
+ * invert({a: 1, b: 2}) // {1: 'a', 2: 'b'}
+ */
+export declare const invert: (obj: AnyObject, deep?: boolean) => AnyObject;
+/**
+ * Maps object values using a callback function
+ * @param obj - Source object
+ * @param callback - Mapping function
+ * @returns New object with mapped values
+ * @example
+ * mapValues({a: 1, b: 2}, (value) => value * 2) // {a: 2, b: 4}
+ */
+/**
+ * Maps object keys using a callback function
+ * @param obj - Source object
+ * @param callback - Mapping function
+ * @returns New object with mapped keys
+ * @example
+ * mapKeys({a: 1, b: 2}, (key) => key.toUpperCase()) // {A: 1, B: 2}
+ */
+/**
+ * Filters object properties using a predicate
+ * @param obj - Source object
+ * @param predicate - Filter function
+ * @returns New object with filtered properties
+ * @example
+ * filter({a: 1, b: 2, c: 3}, (value) => value > 1) // {b: 2, c: 3}
+ */
+export declare const filter: <T extends AnyObject>(obj: T, predicate: (value: T[keyof T], key: keyof T) => boolean) => T extends RecordObject ? Partial<T> : Partial<T>[];
+/**
+ * Flattens a nested object
+ * @param obj - Source object
+ * @param separator - Separator for nested keys (default: '.')
+ * @returns Flattened object
+ * @example
+ * flatten({a: {b: {c: 1}}, d: 2}) // {'a.b.c': 1, d: 2}
+ */
+/**
+ * Unflattens an object (reverse of flatten)
+ * @param obj - Source object
+ * @param separator - Separator used for nested keys (default: '.')
+ * @returns Unflattened object
+ * @example
+ * unflatten({'a.b.c': 1, d: 2}) // {a: {b: {c: 1}}, d: 2}
+ */
+/**
+ * Removes undefined or null properties from an object
+ * @param obj - Source object
+ * @param deep - Whether to clean recursively (default: false)
+ * @returns Cleaned object
+ * @example
+ * clean({a: 1, b: null, c: undefined, d: {e: null}}) // {a: 1, d: {}}
+ * clean({a: 1, b: null, d: {e: null}}, true) // {a: 1}
+ */
+export declare const clean: <T extends AnyObject>(obj: T, deep?: boolean) => Partial<T>;
+/**
+ * Creates a new object with default values
+ * @param defaults - Default values
+ * @param overrides - Override values
+ * @returns Merged object with defaults
+ * @example
+ * defaults({a: 1, b: 2}, {b: 3, c: 4}) // {a: 1, b: 3, c: 4}
+ */
+export declare const defaults: <T extends AnyObject, U extends AnyObject>(current: T, overrides: U) => T & U;
+/**
+ * Gets the size of an object (number of own enumerable properties)
+ * @param obj - Source object
+ * @returns Number of properties
+ * @example
+ * size({a: 1, b: 2, c: 3}) // 3
+ */
+export declare const size: (obj: AnyObject) => number;
+/**
+ * Creates a new object with the same keys but transformed values
+ * @param obj - Source object
+ * @param transformer - Transformation function
+ * @returns Transformed object
+ * @example
+ * transform({a: 1, b: 2}, (key, value) => ({[key]: value * 2})) // {a: 2, b: 4}
+ */
+export declare const transform: <T extends AnyObject>(obj: T, transformer: (key: keyof T, value: T[keyof T]) => [string, any]) => AnyObject;
+/**
+ * Groups an array of objects by a key
+ * @param array - Array of objects
+ * @param key - Key to group by
+ * @returns Grouped object
+ * @example
+ * groupBy([{type: 'a', value: 1}, {type: 'b', value: 2}, {type: 'a', value: 3}], 'type')
+ * // {a: [{type: 'a', value: 1}, {type: 'a', value: 3}], b: [{type: 'b', value: 2}]}
+ */
+export declare const groupBy: <T extends AnyObject>(array: T[], key: keyof T) => Record<string | number, T[]>;
+/**
+ * Converts an object to a query string
+ * @param obj - Source object
+ * @returns Query string
+ * @example
+ * toQueryString({a: 1, b: 'test', c: [1, 2, 3]}) // 'a=1&b=test&c=1&c=2&c=3'
+ */
+export declare const toQueryString: (obj: AnyObject) => string;
+/**
+ * Parses a query string to an object
+ * @param queryString - Query string
+ * @returns Parsed object
+ * @example
+ * fromQueryString('a=1&b=test&c=1&c=2&c=3') // {a: '1', b: 'test', c: ['1', '2', '3']}
+ */
+export declare const fromQueryString: (queryString: string) => AnyObject;
+/**
+ * Creates a frozen deep clone of an object
+ * @param obj - Source object
+ * @returns Deep frozen object
+ * @example
+ * const frozen = deepFreeze({a: {b: 1}})
+ * frozen.a.b = 2 // Error in strict mode
+ */
+export declare const deepFreeze: <T>(obj: T) => DeepReadonly<T>;
+/**
+ * Type guard for non-null object
+ * @param value - Value to check
+ * @returns True if value is a non-null object
+ */
+export declare const isNonNullObject: (value: unknown) => value is AnyObject;
+//# sourceMappingURL=object.d.ts.map

package/dist/lib/object/object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object.d.ts","sourceRoot":"","sources":["../../../src/lib/object/object.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAIxE;;;;;;GAMG;AACH,eAAO,MAAM,MAAM,GAAI,KAAK,SAAS,EAAE,OAAM,OAAe,KAAG,SAgC9D,CAAC;AAEF;;;;;;;GAOG;AAqBH;;;;;;;GAOG;AAsBH;;;;;;;GAOG;AACH,eAAO,MAAM,MAAM,GAAI,CAAC,SAAS,SAAS,EACxC,KAAK,CAAC,EACN,WAAW,CAAC,KAAK,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,KAAK,OAAO,KACtD,CAAC,SAAS,YAAY,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,EAiBlD,CAAC;AAEF;;;;;;;GAOG;AA+CH;;;;;;;GAOG;AA4DH;;;;;;;;GAQG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,SAAS,SAAS,EACvC,KAAK,CAAC,EACN,OAAM,OAAe,KACpB,OAAO,CAAC,CAAC,CAuBX,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,SAAS,SAAS,EAAE,CAAC,SAAS,SAAS,EAC/D,SAAS,CAAC,EACV,WAAW,CAAC,KACX,CAAC,GAAG,CAgBN,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,IAAI,GAAI,KAAK,SAAS,KAAG,MAMrC,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,SAAS,SAAS,EAC3C,KAAK,CAAC,EACN,aAAa,CAAC,GAAG,EAAE,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,MAAM,EAAE,GAAG,CAAC,KAC9D,SAgBF,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,OAAO,GAAI,CAAC,SAAS,SAAS,EACzC,OAAO,CAAC,EAAE,EACV,KAAK,MAAM,CAAC,KACX,MAAM,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC,EAAE,CAqB7B,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,GAAI,KAAK,SAAS,KAAG,MAwB9C,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,GAAI,aAAa,MAAM,KAAG,SAkCrD,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU,GAAI,CAAC,EAAE,KAAK,CAAC,KAAG,YAAY,CAAC,CAAC,CA4BpD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,eAAe,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,SAEzD,CAAC"}