@zairakai/js-utils 1.0.0

package/dist/obj.cjs

@@ -0,0 +1,427 @@
+"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/obj.ts
+var obj_exports = {};
+__export(obj_exports, {
+  Obj: () => Obj,
+  Objectable: () => Objectable,
+  obj: () => obj
+});
+module.exports = __toCommonJS(obj_exports);
+
+// src/equals.ts
+var isEqual = (a, b) => {
+  if (a === b) {
+    return true;
+  }
+  if (a && b && "object" === typeof a && "object" === typeof b) {
+    if (a.constructor !== b.constructor) {
+      return false;
+    }
+    if (Array.isArray(a)) {
+      if (a.length !== b.length) {
+        return false;
+      }
+      for (let i = 0; i < a.length; i++) {
+        if (!isEqual(a[i], b[i])) {
+          return false;
+        }
+      }
+      return true;
+    }
+    if (a instanceof Map && b instanceof Map) {
+      if (a.size !== b.size) {
+        return false;
+      }
+      for (const [key, val] of a) {
+        if (!b.has(key) || !isEqual(val, b.get(key))) {
+          return false;
+        }
+      }
+      return true;
+    }
+    if (a instanceof Set && b instanceof Set) {
+      if (a.size !== b.size) {
+        return false;
+      }
+      for (const val of a) {
+        if (!b.has(val)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    if (a.constructor === RegExp) {
+      return a.source === b.source && a.flags === b.flags;
+    }
+    if (a.valueOf !== Object.prototype.valueOf) {
+      return a.valueOf() === b.valueOf();
+    }
+    if (a.toString !== Object.prototype.toString) {
+      return a.toString() === b.toString();
+    }
+    const keys = Object.keys(a);
+    if (keys.length !== Object.keys(b).length) {
+      return false;
+    }
+    const bObj = b;
+    const aObj = a;
+    for (const key of keys) {
+      if (!Object.prototype.hasOwnProperty.call(bObj, key)) {
+        return false;
+      }
+      if (!isEqual(aObj[key], bObj[key])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return a !== a && b !== b;
+};
+var diff = (original, current) => {
+  const result = {};
+  if (isEqual(original, current)) {
+    return result;
+  }
+  if (!original || !current || "object" !== typeof original || "object" !== typeof current) {
+    return current || {};
+  }
+  const originalObj = original;
+  const currentObj = current;
+  const keys = /* @__PURE__ */ new Set([...Object.keys(originalObj), ...Object.keys(currentObj)]);
+  for (const key of keys) {
+    if (!isEqual(originalObj[key], currentObj[key])) {
+      if (originalObj[key] && currentObj[key] && "object" === typeof originalObj[key] && "object" === typeof currentObj[key] && !Array.isArray(originalObj[key])) {
+        result[key] = diff(originalObj[key], currentObj[key]);
+      } else {
+        result[key] = currentObj[key];
+      }
+    }
+  }
+  return result;
+};
+
+// src/runtime.ts
+function isRecord(value) {
+  return null !== value && "object" === typeof value && !Array.isArray(value);
+}
+var data_get = (target, key, defaultValue = null) => {
+  if (!isRecord(target) && !Array.isArray(target)) {
+    return defaultValue;
+  }
+  const parts = Array.isArray(key) ? key : key.split(".");
+  let result = target;
+  for (const part of parts) {
+    if (!isRecord(result) && !Array.isArray(result)) {
+      return defaultValue;
+    }
+    if (part in result) {
+      result = result[part];
+    } else {
+      return defaultValue;
+    }
+  }
+  return result;
+};
+var data_set = (target, key, value) => {
+  if (!isRecord(target) && !Array.isArray(target)) {
+    return target;
+  }
+  const parts = Array.isArray(key) ? key : key.split(".");
+  let current = target;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (!isRecord(current)) {
+      break;
+    }
+    const currentRecord = current;
+    if (!(part in currentRecord) || !isRecord(currentRecord[part])) {
+      currentRecord[part] = {};
+    }
+    current = currentRecord[part];
+  }
+  if (isRecord(current)) {
+    ;
+    current[parts[parts.length - 1]] = value;
+  }
+  return target;
+};
+
+// src/obj.ts
+var Objectable = class _Objectable {
+  /**
+   * Create a new Objectable instance.
+   *
+   * @param {T} value The initial object value
+   */
+  constructor(value) {
+    this.value = structuredClone(value);
+    this.originalValue = structuredClone(value);
+  }
+  /**
+   * Get the current object state.
+   *
+   * @returns {T} The current object
+   */
+  toObject() {
+    return this.value;
+  }
+  /**
+   * Alias for toObject().
+   *
+   * @returns {T} The current object
+   */
+  get() {
+    return this.value;
+  }
+  /**
+   * Get the original state from construction.
+   *
+   * @returns {T} The original object
+   */
+  getOriginal() {
+    return this.originalValue;
+  }
+  /**
+   * Sync original state with current state (marking it as clean).
+   *
+   * @returns {this} The Objectable instance
+   */
+  syncOriginal() {
+    this.originalValue = structuredClone(this.value);
+    return this;
+  }
+  /**
+   * Determine if any attribute has been modified.
+   *
+   * @param {string} [key] Optional key to check specifically
+   * @returns {boolean} True if dirty, false otherwise
+   */
+  isDirty(key) {
+    if (key) {
+      return !isEqual(data_get(this.originalValue, key), data_get(this.value, key));
+    }
+    return !isEqual(this.originalValue, this.value);
+  }
+  /**
+   * Determine if the object is equivalent to its original state.
+   *
+   * @param {string} [key] Optional key to check specifically
+   * @returns {boolean} True if clean, false otherwise
+   */
+  isClean(key) {
+    return !this.isDirty(key);
+  }
+  /**
+   * Get the attributes that have been modified.
+   *
+   * @returns {Partial<T>} The dirty attributes
+   */
+  getDirty() {
+    return diff(this.originalValue, this.value);
+  }
+  /**
+   * Get a value by dot notation.
+   *
+   * @param {string} key The key to retrieve
+   * @param {unknown} [defaultValue=null] The default value if not found
+   * @returns {unknown} The retrieved value
+   */
+  dataGet(key, defaultValue = null) {
+    return data_get(this.value, key, defaultValue);
+  }
+  /**
+   * Set a value by dot notation.
+   *
+   * @param {string} key The key to set
+   * @param {unknown} value The value to set
+   * @returns {this} The Objectable instance
+   */
+  dataSet(key, value) {
+    data_set(this.value, key, value);
+    return this;
+  }
+  /**
+   * Get only specified keys.
+   *
+   * @param {K[]} keys The keys to include
+   * @returns {Objectable<Pick<T, K>>} A new Objectable instance
+   */
+  only(keys) {
+    const result = {};
+    keys.forEach((key) => {
+      const k = key;
+      if (k in this.value) {
+        result[k] = this.value[k];
+      }
+    });
+    return new _Objectable(result);
+  }
+  /**
+   * Get all keys except specified ones.
+   *
+   * @param {K[]} keys The keys to exclude
+   * @returns {Objectable<Omit<T, K>>} A new Objectable instance
+   */
+  except(keys) {
+    const result = { ...this.value };
+    keys.forEach((key) => {
+      const k = key;
+      delete result[k];
+    });
+    return new _Objectable(result);
+  }
+  /**
+   * Map over object entries.
+   *
+   * @param {Function} callback The callback to execute
+   * @returns {Record<string, U>} The resulting object
+   */
+  map(callback) {
+    const result = {};
+    for (const [key, val] of Object.entries(this.value)) {
+      result[key] = callback(val, key);
+    }
+    return result;
+  }
+  /**
+   * Filter object entries.
+   *
+   * @param {Function} callback The callback to execute
+   * @returns {this} The Objectable instance
+   */
+  filter(callback) {
+    const result = {};
+    for (const [key, val] of Object.entries(this.value)) {
+      if (callback(val, key)) {
+        result[key] = val;
+      }
+    }
+    this.value = result;
+    return this;
+  }
+  /**
+   * Merge with another object.
+   *
+   * @param {U} other The object to merge with
+   * @returns {Objectable<T & U>} A new Objectable instance
+   */
+  merge(other) {
+    return new _Objectable({ ...this.value, ...other });
+  }
+  /**
+   * Deep merge with another object (non-mutating on source).
+   *
+   * @param {Record<string, unknown>} other The object to deep merge with
+   * @returns {this} The Objectable instance
+   */
+  mergeDeep(other) {
+    const merge = (target, source) => {
+      const result = { ...target };
+      for (const key of Object.keys(source)) {
+        const srcVal = source[key];
+        const tgtVal = target[key];
+        if (srcVal !== null && "object" === typeof srcVal && !Array.isArray(srcVal) && tgtVal !== null && "object" === typeof tgtVal && !Array.isArray(tgtVal)) {
+          result[key] = merge(tgtVal, srcVal);
+        } else {
+          result[key] = srcVal;
+        }
+      }
+      return result;
+    };
+    this.value = merge(this.value, other);
+    return this;
+  }
+  /**
+   * Check if object has key.
+   *
+   * @param {string} key The key to check
+   * @returns {boolean} True if key exists
+   */
+  has(key) {
+    return key in this.value;
+  }
+  /**
+   * Get keys.
+   *
+   * @returns {string[]} The object keys
+   */
+  keys() {
+    return Object.keys(this.value);
+  }
+  /**
+   * Get values.
+   *
+   * @returns {unknown[]} The object values
+   */
+  values() {
+    return Object.values(this.value);
+  }
+  /**
+   * Clone the object.
+   *
+   * @returns {Objectable<T>} A new cloned Objectable instance
+   */
+  clone() {
+    return new _Objectable(structuredClone(this.value));
+  }
+  /**
+   * Pipe to a callback.
+   *
+   * @param {Function} callback The callback to execute
+   * @returns {U} The result of the callback
+   */
+  pipe(callback) {
+    return callback(this);
+  }
+  /**
+   * Execute callback if condition is met.
+   *
+   * @param {boolean | Function} condition The condition to check
+   * @param {Function} callback The callback to execute
+   * @returns {this} The Objectable instance
+   */
+  when(condition, callback) {
+    const shouldExecute = "function" === typeof condition ? condition() : condition;
+    if (shouldExecute) {
+      callback(this);
+    }
+    return this;
+  }
+};
+var obj = (value) => {
+  return new Objectable(value);
+};
+var Obj = {
+  /** Create a new Objectable instance */
+  of: (value) => new Objectable(value),
+  /** Get object keys */
+  keys: (value) => Object.keys(value),
+  /** Get object values */
+  values: (value) => Object.values(value),
+  /** Merge objects */
+  merge: (target, ...sources) => Object.assign({}, target, ...sources)
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Obj,
+  Objectable,
+  obj
+});

package/dist/obj.d.cts

@@ -0,0 +1,177 @@
+/**
+ * Fluent object manipulation class with state tracking.
+ */
+declare class Objectable<T extends Record<string, unknown>> {
+    protected value: T;
+    protected originalValue: T;
+    /**
+     * Create a new Objectable instance.
+     *
+     * @param {T} value The initial object value
+     */
+    constructor(value: T);
+    /**
+     * Get the current object state.
+     *
+     * @returns {T} The current object
+     */
+    toObject(): T;
+    /**
+     * Alias for toObject().
+     *
+     * @returns {T} The current object
+     */
+    get(): T;
+    /**
+     * Get the original state from construction.
+     *
+     * @returns {T} The original object
+     */
+    getOriginal(): T;
+    /**
+     * Sync original state with current state (marking it as clean).
+     *
+     * @returns {this} The Objectable instance
+     */
+    syncOriginal(): this;
+    /**
+     * Determine if any attribute has been modified.
+     *
+     * @param {string} [key] Optional key to check specifically
+     * @returns {boolean} True if dirty, false otherwise
+     */
+    isDirty(key?: string): boolean;
+    /**
+     * Determine if the object is equivalent to its original state.
+     *
+     * @param {string} [key] Optional key to check specifically
+     * @returns {boolean} True if clean, false otherwise
+     */
+    isClean(key?: string): boolean;
+    /**
+     * Get the attributes that have been modified.
+     *
+     * @returns {Partial<T>} The dirty attributes
+     */
+    getDirty(): Partial<T>;
+    /**
+     * Get a value by dot notation.
+     *
+     * @param {string} key The key to retrieve
+     * @param {unknown} [defaultValue=null] The default value if not found
+     * @returns {unknown} The retrieved value
+     */
+    dataGet(key: string, defaultValue?: unknown): unknown;
+    /**
+     * Set a value by dot notation.
+     *
+     * @param {string} key The key to set
+     * @param {unknown} value The value to set
+     * @returns {this} The Objectable instance
+     */
+    dataSet(key: string, value: unknown): this;
+    /**
+     * Get only specified keys.
+     *
+     * @param {K[]} keys The keys to include
+     * @returns {Objectable<Pick<T, K>>} A new Objectable instance
+     */
+    only<K extends keyof T>(keys: K[]): Objectable<Pick<T, K>>;
+    /**
+     * Get all keys except specified ones.
+     *
+     * @param {K[]} keys The keys to exclude
+     * @returns {Objectable<Omit<T, K>>} A new Objectable instance
+     */
+    except<K extends keyof T>(keys: K[]): Objectable<Omit<T, K>>;
+    /**
+     * Map over object entries.
+     *
+     * @param {Function} callback The callback to execute
+     * @returns {Record<string, U>} The resulting object
+     */
+    map<U>(callback: (value: T[keyof T], key: keyof T) => U): Record<string, U>;
+    /**
+     * Filter object entries.
+     *
+     * @param {Function} callback The callback to execute
+     * @returns {this} The Objectable instance
+     */
+    filter(callback: (value: T[keyof T], key: keyof T) => boolean): this;
+    /**
+     * Merge with another object.
+     *
+     * @param {U} other The object to merge with
+     * @returns {Objectable<T & U>} A new Objectable instance
+     */
+    merge<U extends Record<string, unknown>>(other: U): Objectable<T & U>;
+    /**
+     * Deep merge with another object (non-mutating on source).
+     *
+     * @param {Record<string, unknown>} other The object to deep merge with
+     * @returns {this} The Objectable instance
+     */
+    mergeDeep(other: Record<string, unknown>): this;
+    /**
+     * Check if object has key.
+     *
+     * @param {string} key The key to check
+     * @returns {boolean} True if key exists
+     */
+    has(key: string): boolean;
+    /**
+     * Get keys.
+     *
+     * @returns {string[]} The object keys
+     */
+    keys(): string[];
+    /**
+     * Get values.
+     *
+     * @returns {unknown[]} The object values
+     */
+    values(): unknown[];
+    /**
+     * Clone the object.
+     *
+     * @returns {Objectable<T>} A new cloned Objectable instance
+     */
+    clone(): Objectable<T>;
+    /**
+     * Pipe to a callback.
+     *
+     * @param {Function} callback The callback to execute
+     * @returns {U} The result of the callback
+     */
+    pipe<U>(callback: (obj: this) => U): U;
+    /**
+     * Execute callback if condition is met.
+     *
+     * @param {boolean | Function} condition The condition to check
+     * @param {Function} callback The callback to execute
+     * @returns {this} The Objectable instance
+     */
+    when(condition: boolean | (() => boolean), callback: (obj: this) => void): this;
+}
+/**
+ * Create a new fluent Objectable instance.
+ *
+ * @param {T} value The initial value
+ * @returns {Objectable<T>} A new Objectable instance
+ */
+declare const obj: <T extends Record<string, unknown>>(value: T) => Objectable<T>;
+/**
+ * Static methods for object manipulation.
+ */
+declare const Obj: {
+    /** Create a new Objectable instance */
+    of: <T extends Record<string, unknown>>(value: T) => Objectable<T>;
+    /** Get object keys */
+    keys: (value: Record<string, unknown>) => string[];
+    /** Get object values */
+    values: (value: Record<string, unknown>) => unknown[];
+    /** Merge objects */
+    merge: (target: Record<string, unknown>, ...sources: Record<string, unknown>[]) => any;
+};
+
+export { Obj, Objectable, obj };