@zairakai/js-utils 1.0.0

package/dist/obj.d.ts

@@ -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 };

package/dist/obj.js

@@ -0,0 +1,12 @@
+import {
+  Obj,
+  Objectable,
+  obj
+} from "./chunk-Z7G3SIQH.js";
+import "./chunk-ZJPKS2MQ.js";
+import "./chunk-LDSWHSRX.js";
+export {
+  Obj,
+  Objectable,
+  obj
+};