@arabig/origin 1.0.0

package/fesm2022/arabig-origin-record.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"arabig-origin-record.mjs","sources":["../../../projects/origin/record/record.ts","../../../projects/origin/record/arabig-origin-record.ts"],"sourcesContent":["/**\r\n * @license\r\n * Copyright Salar Arab All Rights Reserved.\r\n * \r\n * @author Salar Arab <salar_arab@outlook.com>\r\n */\r\n\r\nimport { aoFilterObject } from \"@arabig/origin/functions\";\r\nimport { AoEntryUnion, AoObject } from \"@arabig/origin/types\";\r\n\r\n/**\r\n * Utilizes performing common operations as pipeline on object-like.\r\n *\r\n * @remarks\r\n * {@link AoRecord} provides a fluent and type-safe API for manipulating objects.\r\n * It includes methods for filtering, mapping, and transforming key-value pairs—similar to\r\n * array utilities but designed for object semantics.\r\n *\r\n * This class is ideal for scenarios where object-based data structures need to be processed\r\n * functionally, such as configuration maps, lookup tables, or DTO transformations.\r\n *\r\n * @typeParam T - The type of entries contained in the record.\r\n *\r\n * @example\r\n * ```ts\r\n * const rec = new AoRecord({\r\n * name: \"John\",\r\n * age: 33,\r\n * married: false,\r\n * }).filter(({ key }) => key !== \"age\");\r\n * ```\r\n */\r\nexport class AoRecord<T extends AoObject> {\r\n\r\n  private readonly _entries: T;\r\n\r\n  /**\r\n   * \r\n   * @param defaultEntries The default structure to initialize {@link AoRecord} entries\r\n   */\r\n  constructor(defaultEntries: T) {\r\n    this._entries = defaultEntries;\r\n  }\r\n\r\n  /**\r\n   * @readonly Gets keys of the current entries.\r\n   * @returns An array containing keys of the current entries\r\n   */\r\n  public get keys(): (keyof T)[] {\r\n    return Object.keys(this._entries);\r\n  }\r\n\r\n  /**\r\n   * @readonly Gets values of the current entries.\r\n   * @returns An array containing values of the current entries\r\n   */\r\n  public get values(): T[keyof T][] {\r\n    return Object.values(this._entries) as T[keyof T][];\r\n  }\r\n\r\n  /**\r\n   * @readonly Gets the current entries.\r\n   * @returns An array containing the current entries in form of {@link AoEntryUnion}\r\n   */\r\n  public get entries(): AoEntryUnion<T>[] {\r\n    return Object.entries(this._entries)\r\n      .map(e => ({ key: e[0], value: e[1] })) as AoEntryUnion<T>[];\r\n  }\r\n\r\n  /**\r\n   * Filters the current entries based on given condition.\r\n   * @param predicate The callback that iterates within {@link AoRecord} entries and\r\n   * provides the key and value in form of {@link AoEntryUnion} as parameter and must\r\n   * return a boolean type determines whether the current key should be remained in the\r\n   * resulting entries or not\r\n   * @returns A new instance of {@link AoRecord} containing the {@link Partial} filtered entries.\r\n   */\r\n  public filter(\r\n    predicate: (entry: AoEntryUnion<T>) => boolean\r\n  ): AoRecord<AoObject> {\r\n    return new AoRecord(aoFilterObject(this._entries, predicate));\r\n  }\r\n\r\n  /**\r\n   * Tests the trueness of the given condition for every entry.\r\n   * @param predicate The callback that iterates within {@link AoRecord} entries and\r\n   * provides the key and value in form of {@link AoEntryUnion} as parameter and must\r\n   * return a boolean type determines the condition for current entry\r\n   * @returns True, if the given conditions is true for every entry otherwise false\r\n   */\r\n  public every(\r\n    predicate: (entry: AoEntryUnion<T>) => boolean\r\n  ): boolean {\r\n    for (const key in this._entries) {\r\n      if (!Object.hasOwn(this._entries, key)) continue;\r\n\r\n      if (!predicate({ key: key, value: this._entries[key] })) return false;\r\n    }\r\n\r\n    return true;\r\n  }\r\n\r\n  /**\r\n   * Tests the trueness of the given condition for atleast one entry.\r\n   * @param predicate The callback that iterates within {@link AoRecord} entries and\r\n   * provides the key and value in form of {@link AoEntryUnion} as parameter and must\r\n   * return a boolean type determines the condition for current entry\r\n   * @returns True, if the given conditions is true for atleast one entry otherwise false\r\n   */\r\n  public some(\r\n    predicate: (entry: AoEntryUnion<T>) => boolean\r\n  ): boolean {\r\n    for (const key in this._entries) {\r\n      if (!Object.hasOwn(this._entries, key)) continue;\r\n\r\n      if (predicate({ key: key, value: this._entries[key] })) return true;\r\n    }\r\n\r\n    return false;\r\n  }\r\n\r\n}","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './public-api';\n"],"names":[],"mappings":";;AAAA;;;;;AAKG;AAKH;;;;;;;;;;;;;;;;;;;;;AAqBG;MACU,QAAQ,CAAA;AAEF,IAAA,QAAQ;AAEzB;;;AAGG;AACH,IAAA,WAAA,CAAY,cAAiB,EAAA;AAC3B,QAAA,IAAI,CAAC,QAAQ,GAAG,cAAc;IAChC;AAEA;;;AAGG;AACH,IAAA,IAAW,IAAI,GAAA;QACb,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC;IACnC;AAEA;;;AAGG;AACH,IAAA,IAAW,MAAM,GAAA;QACf,OAAO,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAiB;IACrD;AAEA;;;AAGG;AACH,IAAA,IAAW,OAAO,GAAA;AAChB,QAAA,OAAO,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ;aAChC,GAAG,CAAC,CAAC,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAsB;IAChE;AAEA;;;;;;;AAOG;AACI,IAAA,MAAM,CACX,SAA8C,EAAA;AAE9C,QAAA,OAAO,IAAI,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;IAC/D;AAEA;;;;;;AAMG;AACI,IAAA,KAAK,CACV,SAA8C,EAAA;AAE9C,QAAA,KAAK,MAAM,GAAG,IAAI,IAAI,CAAC,QAAQ,EAAE;YAC/B,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,GAAG,CAAC;gBAAE;AAExC,YAAA,IAAI,CAAC,SAAS,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;AAAE,gBAAA,OAAO,KAAK;QACvE;AAEA,QAAA,OAAO,IAAI;IACb;AAEA;;;;;;AAMG;AACI,IAAA,IAAI,CACT,SAA8C,EAAA;AAE9C,QAAA,KAAK,MAAM,GAAG,IAAI,IAAI,CAAC,QAAQ,EAAE;YAC/B,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,GAAG,CAAC;gBAAE;AAExC,YAAA,IAAI,SAAS,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;AAAE,gBAAA,OAAO,IAAI;QACrE;AAEA,QAAA,OAAO,KAAK;IACd;AAED;;ACzHD;;AAEG;;;;"}

package/fesm2022/arabig-origin-types.mjs

@@ -0,0 +1,25 @@
+/**
+ * @license
+ * Copyright Salar Arab All Rights Reserved.
+ *
+ * @author Salar Arab <salar_arab@outlook.com>
+ */
+
+/**
+ * @license
+ * Copyright Salar Arab All Rights Reserved.
+ *
+ * @author Salar Arab <salar_arab@outlook.com>
+ */
+
+/**
+* @license
+* Copyright Agin Company All Rights Reserved
+*
+* @author Salar Arab <salar.arab.70@gmail.com>
+*/
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+//# sourceMappingURL=arabig-origin-types.mjs.map

package/fesm2022/arabig-origin-types.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"arabig-origin-types.mjs","sources":["../../../projects/origin/types/utility.type.ts","../../../projects/origin/types/constant.type.ts","../../../projects/origin/types/checker.type.ts","../../../projects/origin/types/arabig-origin-types.ts"],"sourcesContent":["/**\r\n * @license\r\n * Copyright Salar Arab All Rights Reserved.\r\n * \r\n * @author Salar Arab <salar_arab@outlook.com>\r\n */\r\n\r\n/**\r\n * Represents a union of the given type, `undefined` and `null`.\r\n * @typeParam `T` The type that the union is based on\r\n */\r\nexport type AoNullish<T> = T | null | undefined;\r\n\r\n/**\r\n * Represents a discriminated union of the passed type parameter's possible enteries\r\n * based on its keys.\r\n * @typeParam `T` The type that the union is based on\r\n */\r\nexport type AoEntryUnion<T> = {\r\n  [K in keyof T]: { key: K; value: T[K] }\r\n}[keyof T];\r\n\r\n/**\r\n * Represents a key-value pair in form of a two elements tuple that its first element\r\n * is the key and the second one is the value.\r\n */\r\nexport type AoEntry<T> = [keyof T, T[keyof T]];\r\n\r\n/**\r\n * Represents an `object` with loose or typed structure base on given type parameter.\r\n * @typeParam `T` The type that determines the structure of the resulting `object`.\r\n * If omitted, a complete loose structure will be considered\r\n */\r\nexport type AoObject<T extends Record<any, any> = any> = \r\n  T extends any[]\r\n    ? never\r\n    : T extends (...p: any[]) => any\r\n      ? never\r\n      : unknown extends T\r\n        ? Record<any, any>\r\n        : { [K in keyof T]: T[K] };\r\n\r\n/**\r\n * Represents an `object` that includes a loose minimal structure base on passed type\r\n * parameter.\r\n * @typeParam `T` The `object` based that forms the minimal structure, if omitted\r\n * a complete loose structure will be considered\r\n */\r\nexport type AoLooseObject<T extends AoObject = AoObject> = AoObject & T;\r\n\r\n/**\r\n * Represents a `string` literal union of the given `enum` values.\r\n * @typeParam `T`The `enum` type\r\n * @typeParam `TDefault` The type that determines the default case of the `enum` values union\r\n */\r\nexport type AoEnumValue<T extends string, TDefault extends string = never> = `${T}` | TDefault;\r\n\r\n/**\r\n * Represents an optional `string` literal union of the given `enum` values.\r\n * @typeParam `T`The `enum` type\r\n */\r\nexport type AoEnumOptionalValue<T extends string> = `${T}` | String;\r\n\r\n/**\r\n * Represents either a typed union of specific keys or a plain primitive key\r\n * base on given type parameter.\r\n * @typeParam `T` The type that determines the keys union or a primitive key if omitted\r\n */\r\nexport type AoKey<T = unknown> = unknown extends T\r\n  ? string | number | symbol\r\n  : keyof T;\r\n\r\n/**\r\n * Represents either a typed union of specific keys or a `string` key\r\n * base on given type parameter.\r\n * @typeParam `T` The type that determines the keys union or a string key if omitted\r\n */  \r\nexport type AoStringKey<T = unknown> = unknown extends T\r\n  ? string\r\n  : Exclude<keyof T, number | symbol>;\r\n\r\n/**\r\n * Represents either a typed union of specific keys or a plain primitive key\r\n * base on given type parameter for all nested types.\r\n * @typeParam `T` The type that determines the keys union or a primitive key if omitted\r\n * @remarks Using this type for deeply nested types can prove slow compilation time.\r\n */\r\nexport type AoDeepKey<T = unknown> = unknown extends T\r\n  ? string | number | symbol\r\n  : {\r\n      [K in keyof T]: T[K] extends object\r\n        ? K | AoDeepKey<T[K]>\r\n        : K\r\n  }[keyof T];\r\n\r\n/**\r\n * Represents either a typed union of specific keys or a `string` key\r\n * base on given type parameter for all nested types.\r\n * @typeParam `T` The type that determines the keys union or a `string` key if omitted\r\n * @remarks Using this type for deeply nested types can prove slow compilation time.\r\n */\r\nexport type AoDeepStringKey<T = unknown> = unknown extends T\r\n  ? string\r\n  : Exclude<\r\n    {\r\n        [K in keyof T]: T[K] extends object\r\n          ? K | AoDeepKey<T[K]>\r\n          : K\r\n    }[keyof T], number | symbol\r\n  >;","/**\r\n * @license\r\n * Copyright Salar Arab All Rights Reserved.\r\n * \r\n * @author Salar Arab <salar_arab@outlook.com>\r\n */\r\n\r\n/**\r\n * Represents a union of JavaScript primitive data types.\r\n * @see {@link https://developer.mozilla.org/en-US/docs/Glossary/Primitive | Primitive}\r\n */\r\nexport type AoPrimitive = string | number | boolean | bigint | undefined | null | symbol;\r\n\r\n/**\r\n * Represents a union of JavaScript falsy values.\r\n * @see {@link https://developer.mozilla.org/en-US/docs/Glossary/Falsy | Falsy}\r\n */\r\nexport type AoFalsy = undefined | null | false | 0 | -0 | 0n | \"\";\r\n\r\n\r\n/**\r\n * Represents an object that is a CSS declaration block, and exposes style information\r\n * and various style-related methods and properties.\r\n * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/CSSStyleDeclaration | CSSStyleDeclaration}\r\n */\r\nexport type AoStyle = Partial<CSSStyleDeclaration>;\r\n\r\n/**\r\n * Represents a numeric `string` type\r\n */\r\nexport type AoDigit = `${number}`;\r\n\r\n/**\r\n * Represents a union of the `typeof` keyword result values\r\n * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/typeof | typeof}\r\n */\r\nexport type AoTypeOf =\r\n  | 'string'\r\n  | 'number'\r\n  | 'boolean'\r\n  | 'symbol'\r\n  | 'undefined'\r\n  | 'object'\r\n  | 'function'\r\n  | 'bigint';","/**\r\n* @license\r\n* Copyright Agin Company All Rights Reserved\r\n* \r\n* @author Salar Arab <salar.arab.70@gmail.com>\r\n*/\r\n\r\n/**\r\n * Checks whether the passed type is only assignable to a minimal unbound JS `object`.\r\n * @typeParam `T` The type to be checked\r\n */\r\nexport type AoIsObject<T> = T extends \r\n  | any[]\r\n  | Function\r\n  | ((...p: any[]) => any)\r\n    ? never\r\n    : T extends Record<any, any>\r\n      ? T\r\n      : never;\r\n\r\n/**\r\n * Checks whether the passed type is only assignable to a minimal unbound JS `array`.\r\n * @typeParam `T` The type to be checked\r\n */\r\nexport type AoIsArray<T> = T extends any[]\r\n  ? T\r\n  : never;\r\n\r\n/**\r\n * Checks whether the passed type is only assignable to a minimal callable JS `function`.\r\n * @typeParam `T` The type to be checked\r\n */\r\nexport type AoIsFunction<T> = T extends (...p: any[]) => any\r\n  ? T\r\n  : never;","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './public-api';\n"],"names":[],"mappings":"AAAA;;;;;AAKG;;ACLH;;;;;AAKG;;ACLH;;;;;AAKE;;ACLF;;AAEG"}

package/fesm2022/arabig-origin-vault.mjs

@@ -0,0 +1,176 @@
+/**
+ * @license
+ * Copyright Salar Arab All Rights Reserved.
+ *
+ * @author Salar Arab <salar_arab@outlook.com>
+ */
+/**
+ * Represents a type-safe collection that stores and retrieves values using unique,
+ * typed tokens.
+ *
+ * This class utilizes an abstract data structure similar to `Map`, but replaces generic keys
+ * with {@link AoToken} instances to ensure both **uniqueness** and **type safety**. Each token
+ * carries a generic type parameter that enforces the expected value type at compile time,
+ * preventing mismatches and enhancing developer experience.
+ *
+ * Ideal for use cases such as dependency registries, metadata stores, or scoped configuration
+ * systems where strong typing and collision-free keying are critical.
+ *
+ * @see {@link https://en.wikipedia.org/wiki/Abstract_data_type | Abstract data type}
+ *
+ * @typeParam `TValue` Determines the storeable value type range
+ *
+ * @remarks
+ * - Tokens are guaranteed to be unique via their internal `Symbol` identifier.
+ * - Values are type-checked against the token’s generic parameter.
+ * - This structure improves safety and clarity in large-scale, modular applications.
+ *
+ * @example
+ * ```ts
+ * const data = { meta: "data" };
+ *
+ * const DATA_TOKEN = new AoToken<{ meta: "data" }>();
+ *
+ * const collection = new AoVault().store(DATA_TOKEN, data);
+ *
+ * const value = collection.retrieve(DATA_TOKEN); //inferred as { meta: "data" } | null;
+ * ```
+ */
+class AoVault {
+    _vault;
+    /**
+     * Creates a new instance with optional initial entries.
+     * @param entries The optional initial entries as token-value `tuples`
+     */
+    constructor(entries) {
+        this._vault = new Map(entries);
+    }
+    /**
+     * Checks if an associated entry exists for the given token.
+     * @param token An instance of {@link AoToken} as querying token
+     * @returns The result of the query as `boolean`
+     */
+    exists(token) {
+        return this._vault.has(token);
+    }
+    /**
+     * Stores the given entry base on {@link AoToken}.
+     * @typeParam `T` The type of storing value that must be assignable to {@link AoVault} `TValue` generic type
+     * @param token An instance of {@link AoToken} as querying token
+     * @param value The storing value
+     * @returns The current instance of {@link AoVault}
+     */
+    store(token, value) {
+        this._vault.set(token, value);
+        return this;
+    }
+    /**
+     * Retrieves the associated value base on given {@link AoToken}.
+     * @typeParam `T` The type of retrieving value that must be assignable to {@link AoVault} `TValue` generic type
+     * @param token An instance of {@link AoToken} as querying token
+     * @returns The associated value
+     */
+    retrieve(token) {
+        return this._vault.get(token) ?? null;
+    }
+    /**
+     * Deletes the associated entry base on given {@link AoToken}.
+     * @typeParam `T` The type of deleting value that must be assignable to {@link AoVault} `TValue` generic type
+     * @param token An instance of {@link AoToken} as querying token
+     * @returns The associated value before deleting the entry
+     */
+    delete(token) {
+        if (this._vault.has(token)) {
+            const _value = this._vault.get(token) ?? null;
+            this._vault.delete(token);
+            return _value;
+        }
+        else {
+            return null;
+        }
+    }
+}
+
+/**
+ * @license
+ * Copyright Salar Arab All Rights Reserved.
+ *
+ * @author Salar Arab <salar_arab@outlook.com>
+ */
+/**
+ * Represents a uniquely created token-like entity which can be associated with a
+ * corresponding value.
+ *
+ * @remarks
+ * Each `AoToken` instance encapsulates a unique `Symbol` identifier, ensuring
+ * collision-free keying even across modules. The generic type parameter `T` allows
+ * consumers to associate a specific value type with the token, enabling type-safe
+ * retrieval from collections.
+ *
+ * This pattern is especially useful in scenarios like dependency injection,
+ * metadata registries, or strongly typed key-value stores.
+ *
+ * @typeParam `T` The type of value associated with this token.
+ *
+ * @example
+ * ```ts
+ * const BASE_URL_TK = new AoToken<string>("website base URL");
+ *
+ * const collection = new Map();
+ *
+ * function getValue<T>(token: AoToken<T>): T | null {
+      return collection.get(token) ?? null;
+   }
+ *
+ * const value = getValue(BASE_URL_TK); //inferred as string | null
+ * ```
+ */
+class AoToken {
+    /**
+     * @remarks Do not use this property in the inheritance, since it reserved for
+     * semantic usage of `T` type parameter.
+     */
+    $implicitType;
+    _identifier;
+    _description;
+    /**
+     * Creates a new instance with optional given description.
+     * @param description An optional string description
+     */
+    constructor(description) {
+        this._identifier = Symbol(description ?? "");
+        this._description = description ?? "";
+    }
+    /**
+     * @readonly The `symbol` base identifier which is unique for each intance
+     * @remarks It is recommended to use this property for identification or comparsion
+     * purposes.
+     */
+    get identifier() {
+        return this._identifier;
+    }
+    /**
+     * @readonly The description about this token instance.
+     * @remarks It is not recommended to use this property for identification or
+     * comparsion purposes, since it's just a simple description about the token instance.
+     * Use the `identifier` property for this matter.
+     */
+    get description() {
+        return this._description;
+    }
+    /**
+     * Compares the given `AoToken` with the current instance.
+     * @param comparable The comparing `AoToken` instance
+     * @returns The comparsion result as `boolean`
+     */
+    equals(comparable) {
+        return comparable.identifier === this.identifier;
+    }
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AoToken, AoVault };
+//# sourceMappingURL=arabig-origin-vault.mjs.map

package/fesm2022/arabig-origin-vault.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"arabig-origin-vault.mjs","sources":["../../../projects/origin/vault/vault.ts","../../../projects/origin/vault/token.ts","../../../projects/origin/vault/arabig-origin-vault.ts"],"sourcesContent":["/**\r\n * @license\r\n * Copyright Salar Arab All Rights Reserved.\r\n * \r\n * @author Salar Arab <salar_arab@outlook.com>\r\n */\r\n\r\nimport { AoToken } from \"./token\";\r\n\r\n/**\r\n * Represents a type-safe collection that stores and retrieves values using unique,\r\n * typed tokens.\r\n *\r\n * This class utilizes an abstract data structure similar to `Map`, but replaces generic keys\r\n * with {@link AoToken} instances to ensure both **uniqueness** and **type safety**. Each token\r\n * carries a generic type parameter that enforces the expected value type at compile time,\r\n * preventing mismatches and enhancing developer experience.\r\n *\r\n * Ideal for use cases such as dependency registries, metadata stores, or scoped configuration\r\n * systems where strong typing and collision-free keying are critical.\r\n *\r\n * @see {@link https://en.wikipedia.org/wiki/Abstract_data_type | Abstract data type}\r\n * \r\n * @typeParam `TValue` Determines the storeable value type range\r\n *\r\n * @remarks\r\n * - Tokens are guaranteed to be unique via their internal `Symbol` identifier.\r\n * - Values are type-checked against the token’s generic parameter.\r\n * - This structure improves safety and clarity in large-scale, modular applications.\r\n *\r\n * @example\r\n * ```ts\r\n * const data = { meta: \"data\" };\r\n *\r\n * const DATA_TOKEN = new AoToken<{ meta: \"data\" }>();\r\n *\r\n * const collection = new AoVault().store(DATA_TOKEN, data);\r\n *\r\n * const value = collection.retrieve(DATA_TOKEN); //inferred as { meta: \"data\" } | null;\r\n * ```\r\n */\r\nexport class AoVault<TValue = any> {\r\n\r\n  private readonly _vault: Map<AoToken<TValue>, TValue>;\r\n\r\n  /**\r\n   * Creates a new instance with optional initial entries.\r\n   * @param entries The optional initial entries as token-value `tuples`\r\n   */\r\n  constructor(entries?: [AoToken<TValue>, TValue][]) {\r\n    this._vault = new Map(entries);\r\n  }\r\n\r\n  /**\r\n   * Checks if an associated entry exists for the given token.\r\n   * @param token An instance of {@link AoToken} as querying token\r\n   * @returns The result of the query as `boolean`\r\n   */\r\n  public exists(token: AoToken<TValue>): boolean {\r\n    return this._vault.has(token);\r\n  }\r\n\r\n  /**\r\n   * Stores the given entry base on {@link AoToken}.\r\n   * @typeParam `T` The type of storing value that must be assignable to {@link AoVault} `TValue` generic type\r\n   * @param token An instance of {@link AoToken} as querying token\r\n   * @param value The storing value\r\n   * @returns The current instance of {@link AoVault}\r\n   */\r\n  public store<T extends TValue>(token: AoToken<T>, value: T): AoVault<TValue> {\r\n    this._vault.set(token, value);\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Retrieves the associated value base on given {@link AoToken}.\r\n   * @typeParam `T` The type of retrieving value that must be assignable to {@link AoVault} `TValue` generic type\r\n   * @param token An instance of {@link AoToken} as querying token\r\n   * @returns The associated value\r\n   */\r\n  public retrieve<T extends TValue>(token: AoToken<T>): T | null {\r\n    return this._vault.get(token) as T ?? null;\r\n  }\r\n\r\n  /**\r\n   * Deletes the associated entry base on given {@link AoToken}.\r\n   * @typeParam `T` The type of deleting value that must be assignable to {@link AoVault} `TValue` generic type\r\n   * @param token An instance of {@link AoToken} as querying token\r\n   * @returns The associated value before deleting the entry\r\n   */\r\n  public delete<T extends TValue>(token: AoToken<T>): T | null {\r\n    if (this._vault.has(token)) {\r\n      const _value = this._vault.get(token) as T ?? null;\r\n      \r\n      this._vault.delete(token);\r\n      \r\n      return _value;\r\n    }\r\n    else {\r\n      return null;\r\n    }\r\n  }\r\n\r\n}","/**\r\n * @license\r\n * Copyright Salar Arab All Rights Reserved.\r\n * \r\n * @author Salar Arab <salar_arab@outlook.com>\r\n */\r\n\r\n/**\r\n * Represents a uniquely created token-like entity which can be associated with a \r\n * corresponding value.\r\n * \r\n * @remarks\r\n * Each `AoToken` instance encapsulates a unique `Symbol` identifier, ensuring\r\n * collision-free keying even across modules. The generic type parameter `T` allows\r\n * consumers to associate a specific value type with the token, enabling type-safe\r\n * retrieval from collections.\r\n *\r\n * This pattern is especially useful in scenarios like dependency injection,\r\n * metadata registries, or strongly typed key-value stores.\r\n *\r\n * @typeParam `T` The type of value associated with this token.\r\n *\r\n * @example\r\n * ```ts\r\n * const BASE_URL_TK = new AoToken<string>(\"website base URL\");\r\n * \r\n * const collection = new Map();\r\n * \r\n * function getValue<T>(token: AoToken<T>): T | null {\r\n      return collection.get(token) ?? null;\r\n   }\r\n * \r\n * const value = getValue(BASE_URL_TK); //inferred as string | null\r\n * ```\r\n */\r\nexport class AoToken<T> {\r\n\r\n  /**\r\n   * @remarks Do not use this property in the inheritance, since it reserved for\r\n   * semantic usage of `T` type parameter.\r\n   */\r\n  protected $implicitType?: T;\r\n\r\n  private readonly _identifier: symbol;\r\n\r\n  private readonly _description: string;\r\n\r\n  /**\r\n   * Creates a new instance with optional given description.\r\n   * @param description An optional string description\r\n   */\r\n  constructor(description?: string | null) {\r\n    this._identifier = Symbol(description ?? \"\");\r\n    this._description = description ?? \"\";\r\n  }\r\n\r\n  /**\r\n   * @readonly The `symbol` base identifier which is unique for each intance\r\n   * @remarks It is recommended to use this property for identification or comparsion\r\n   * purposes.\r\n   */\r\n  public get identifier() {\r\n    return this._identifier;\r\n  }\r\n\r\n  /**\r\n   * @readonly The description about this token instance.\r\n   * @remarks It is not recommended to use this property for identification or\r\n   * comparsion purposes, since it's just a simple description about the token instance.\r\n   * Use the `identifier` property for this matter.\r\n   */\r\n  public get description() {\r\n    return this._description;\r\n  }\r\n\r\n  /**\r\n   * Compares the given `AoToken` with the current instance.\r\n   * @param comparable The comparing `AoToken` instance\r\n   * @returns The comparsion result as `boolean`\r\n   */\r\n  public equals(comparable: AoToken<unknown>): boolean {\r\n    return comparable.identifier === this.identifier;\r\n  }\r\n\r\n}","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './public-api';\n"],"names":[],"mappings":"AAAA;;;;;AAKG;AAIH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BG;MACU,OAAO,CAAA;AAED,IAAA,MAAM;AAEvB;;;AAGG;AACH,IAAA,WAAA,CAAY,OAAqC,EAAA;QAC/C,IAAI,CAAC,MAAM,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC;IAChC;AAEA;;;;AAIG;AACI,IAAA,MAAM,CAAC,KAAsB,EAAA;QAClC,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC;IAC/B;AAEA;;;;;;AAMG;IACI,KAAK,CAAmB,KAAiB,EAAE,KAAQ,EAAA;QACxD,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,EAAE,KAAK,CAAC;AAC7B,QAAA,OAAO,IAAI;IACb;AAEA;;;;;AAKG;AACI,IAAA,QAAQ,CAAmB,KAAiB,EAAA;QACjD,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAM,IAAI,IAAI;IAC5C;AAEA;;;;;AAKG;AACI,IAAA,MAAM,CAAmB,KAAiB,EAAA;QAC/C,IAAI,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE;AAC1B,YAAA,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAM,IAAI,IAAI;AAElD,YAAA,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC;AAEzB,YAAA,OAAO,MAAM;QACf;aACK;AACH,YAAA,OAAO,IAAI;QACb;IACF;AAED;;ACvGD;;;;;AAKG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BG;MACU,OAAO,CAAA;AAElB;;;AAGG;AACO,IAAA,aAAa;AAEN,IAAA,WAAW;AAEX,IAAA,YAAY;AAE7B;;;AAGG;AACH,IAAA,WAAA,CAAY,WAA2B,EAAA;QACrC,IAAI,CAAC,WAAW,GAAG,MAAM,CAAC,WAAW,IAAI,EAAE,CAAC;AAC5C,QAAA,IAAI,CAAC,YAAY,GAAG,WAAW,IAAI,EAAE;IACvC;AAEA;;;;AAIG;AACH,IAAA,IAAW,UAAU,GAAA;QACnB,OAAO,IAAI,CAAC,WAAW;IACzB;AAEA;;;;;AAKG;AACH,IAAA,IAAW,WAAW,GAAA;QACpB,OAAO,IAAI,CAAC,YAAY;IAC1B;AAEA;;;;AAIG;AACI,IAAA,MAAM,CAAC,UAA4B,EAAA;AACxC,QAAA,OAAO,UAAU,CAAC,UAAU,KAAK,IAAI,CAAC,UAAU;IAClD;AAED;;ACpFD;;AAEG;;;;"}

package/fesm2022/arabig-origin.mjs

@@ -0,0 +1,11 @@
+/*
+ * Public API Surface of origin
+ */
+const _publicOriginNoopPrimaryExport = false;
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { _publicOriginNoopPrimaryExport };
+//# sourceMappingURL=arabig-origin.mjs.map

package/fesm2022/arabig-origin.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"arabig-origin.mjs","sources":["../../../projects/origin/public-api.ts","../../../projects/origin/arabig-origin.ts"],"sourcesContent":["/*\r\n * Public API Surface of origin\r\n */\r\n\r\nexport const _publicOriginNoopPrimaryExport = false;","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './public-api';\n"],"names":[],"mappings":"AAAA;;AAEG;AAEI,MAAM,8BAA8B,GAAG;;ACJ9C;;AAEG;;;;"}

package/functions/index.d.ts

@@ -0,0 +1,73 @@
+import { AoObject, AoEntryUnion } from '@arabig/origin/types';
+
+/**
+ * @license
+ * Copyright Salar Arab All Rights Reserved.
+ *
+ * @author Salar Arab <salar_arab@outlook.com>
+ */
+/**
+ * Converts the given value to a number based on given options.
+ * @param value The convertible input value.
+ * @param options The options object that handles different cases of numeric conversion.
+ * @returns The resulting number of the conversion
+ *
+ * @example
+ * doToNumber("563.68", {
+ *  infinityAlt: 0,
+ *  NaNAlt: 0
+ * });
+ */
+declare function aoToNumber(value?: unknown, options?: {
+    /**
+    * Determines the alternative value, if the conversion results in {@link NaN}.
+    * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN | NaN}
+    *
+    * @default 0
+    */
+    NaNAlt?: number;
+    /**
+    * Determines the alternative value, if the conversion leads to {@link Infinity}.
+    * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Infinity | Infinity}
+    *
+    * @default 0
+    */
+    infinityAlt?: number;
+}): number;
+/**
+ * Extracts the decimal part of the given value and returns it as raw string.
+ * @param value The input value whose decimal part is demanded.
+ * @returns The extracted decimal part as numeric string or empty string if no decimal part is found.
+ */
+declare function aoExtractDecimal(value: unknown): `${number}` | "";
+/**
+ * Extracts the integer part of the given value and returns it as numeric string.
+ * @param value The input value whose integer part is demanded.
+ * @returns The extracted integer part as numeric string or empty string if no integer part is found.
+ */
+declare function aoExtractInteger(value: unknown): `${number}` | "";
+
+/**
+ * @license
+ * Copyright Salar Arab All Rights Reserved.
+ *
+ * @author Salar Arab <salar_arab@outlook.com>
+ */
+
+/**
+ * Filters the given target object entries based on given condition.
+ * @typeParam `T` The type of the target object to be filtered
+ * @param target The `object` to be filtered
+ * @param predicate The callback that iterates within target entries.
+ * Provides the key and value in form of {@link DoEntryUnion} as parameter and must
+ * return a boolean type determines whether the current key should be remained in the
+ * resulting entries or not
+ * @returns The filtered `object`.
+ * @remarks
+ * Since the structure of the returning `object` is formed during the runtime, the
+ * type inference at the compile time is not possible, so an unbound `object` is considered
+ * as the return type.
+ */
+declare function aoFilterObject<T extends AoObject>(target: T, predicate: (entry: AoEntryUnion<T>) => boolean): AoObject;
+
+export { aoExtractDecimal, aoExtractInteger, aoFilterObject, aoToNumber };

package/index.d.ts

@@ -0,0 +1,3 @@
+declare const _publicOriginNoopPrimaryExport = false;
+
+export { _publicOriginNoopPrimaryExport };

package/operand/index.d.ts

@@ -0,0 +1,148 @@
+/**
+ * @license
+ * Copyright Salar Arab All Rights Reserved
+ *
+ * @author Salar Arab <salar_arab@outlook.com>
+ */
+/**
+ * Represents a numeric string
+ */
+type Digits = `${number}`;
+/**
+ * The convertible input type used mostly in calculation methods
+ */
+type RawInput = string | number | bigint | null | undefined;
+/**
+ * Represents different states of the value
+ */
+type ValueState = "current" | "previous" | "initial";
+/**
+ * Utilizes performing precise arithmetic operations
+ * such as addition, subtraction, multiplication, and division in the form of pipeline.
+ *
+ * This class is designed to handle extremely large or small numeric values
+ * without resulting in {@link Infinity} or {@link NaN}, ensuring safe and predictable
+ * calculations across a wide range of inputs.
+ *
+ * All operations are performed using numeric strings to maintain precision,
+ * especially for decimal values, avoiding floating-point inaccuracies common
+ * in native JavaScript number handling.
+ *
+ * @example
+ * ```ts
+ * const operand = new AoOperand(0.005).add(1.05).add(0.005);
+ *
+ * console.log(operand.currentValue) //expecting "1.06";
+ * ```
+ *
+ * @remarks
+ * This class is ideal for financial, scientific, or any domain where
+ * precision and scale are critical. It does not rely on native number
+ * arithmetic and instead uses string-based computation to preserve accuracy.
+ */
+declare class AoOperand {
+    private readonly _initialValue;
+    private _previousValue;
+    private _currentValue;
+    /**
+     * Creates a new instance based on given instance.
+     * @param instance An instance of {@link AoOperand}
+     */
+    constructor(instance: AoOperand);
+    /**
+     * Creates a new instance of {@link AoOperand} with provided initial value.
+     * @param initialValue
+     * The initial value of the calculation. If the value is not provided or not numeric
+     * convertible, is assigned to "0".
+     */
+    constructor(initialValue?: RawInput);
+    /**
+     * Converts and outputs the {@link AoOperand}'s value as number base on given state.
+     * @param state The state that determines temporal state of the value. Default is "current"
+     * @returns A number
+     */
+    toNumber(state?: ValueState): number;
+    /**
+     * Converts and outputs the {@link AoOperand}'s value as bigint base on given state.
+     * @param state The state that determines temporal state of the value. Default is "current"
+     * @returns A bigint
+     */
+    toBigInt(state?: ValueState): bigint;
+    /**
+     * Converts and outputs the {@link AoOperand}'s value as numeric string base on given state.
+     * @param state The state that determines temporal state of the value. Default is "current"
+     * @returns A numeric string
+     */
+    toString(state?: ValueState): Digits;
+    /**
+     * Executes the Executes the {@link https://en.wikipedia.org/wiki/Addition | addition}
+     * operation for the given value.
+     * @param input The adding operand
+     * @returns A new instance of {@link AoOperand} that holds the operation latest result
+     */
+    add(input: RawInput): AoOperand;
+    /**
+     * Executes the {@link https://en.wikipedia.org/wiki/Subtraction | subtraction}
+     * operation for the given value.
+     * @param input The subtracting operand
+     * @returns A new instance of {@link AoOperand} that holds the operation latest result
+     */
+    subtract(input: RawInput): AoOperand;
+    /**
+     * Executes the {@link https://en.wikipedia.org/wiki/Multiplication | multiplication}
+     * operation for the given value.
+     * @param input The multiplying operand
+     * @returns A new instance of {@link AoOperand} that holds the operation latest result
+     */
+    multiply(input: RawInput): AoOperand;
+    /**
+   * Executes the {@link https://en.wikipedia.org/wiki/Division_(mathematics) | division}
+   * operation for the given value.
+   * @param input The dividing operand
+   * @param options The option object that determines calculation behavior.
+   * @returns A new instance of {@link AoOperand} that holds the operation latest result
+   */
+    divide(input: RawInput, options?: {
+        /**
+         * The number of decimal places to keep. The default value is 10
+         */
+        precision?: number;
+        /**
+         * The alternative value in case of divide by zero
+         */
+        divideByZeroAlt?: RawInput;
+    }): AoOperand;
+    /**
+     * Creates a new instance based on current instance.
+     * @returns A new {@link AoOperand} instance
+     */
+    private clone;
+    /**
+     * Takes snapshot from the current value then assigns the given value to it.
+     * @param value the input value that updates the current value
+     */
+    private assign;
+    /**
+     * Restrains the given number operation by switching to its bigint alternative
+     * if it leads to {@link Infinity}.
+     * @param finiteOperator The callback that returns number
+     * @param infiniteOperator The callback that returns bigint
+     * @returns A numeric string
+     */
+    private restrain;
+    /**
+     * Creates an info object from raw input that provides refined number parts for calculation.
+     * @param input The raw input needed for refinement.
+     * @returns An object info providing refined data for calculation
+     */
+    private refine;
+    /**
+     * Normalizes the decimal part if all of its digits are "0" and removes trailing zeros.
+     * @param integer The integer part of the value
+     * @param decimal The decimal part of the value
+     * @returns The normalized numeric string
+     */
+    private normalize;
+}
+
+export { AoOperand };

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@arabig/origin",
+  "version": "1.0.0",
+  "author": {
+    "name": "Salar Arab",
+    "email": "salar_arab@outlook.com"
+  },
+  "description": "@arabig TypeScript Library",
+  "homepage": "https://github.com/salar-arab/ng-workspace",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/salar-arab/ng-workspace"
+  },
+  "bugs": {
+    "url": "https://github.com/salar-arab/ng-workspace/issues"
+  },
+  "keywords": [
+    "TypeScript",
+    "TS",
+    "library"
+  ],
+  "license": "UNLICENSED",
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "sideEffects": false,
+  "module": "fesm2022/arabig-origin.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./fesm2022/arabig-origin.mjs"
+    },
+    "./functions": {
+      "types": "./functions/index.d.ts",
+      "default": "./fesm2022/arabig-origin-functions.mjs"
+    },
+    "./operand": {
+      "types": "./operand/index.d.ts",
+      "default": "./fesm2022/arabig-origin-operand.mjs"
+    },
+    "./record": {
+      "types": "./record/index.d.ts",
+      "default": "./fesm2022/arabig-origin-record.mjs"
+    },
+    "./types": {
+      "types": "./types/index.d.ts",
+      "default": "./fesm2022/arabig-origin-types.mjs"
+    },
+    "./vault": {
+      "types": "./vault/index.d.ts",
+      "default": "./fesm2022/arabig-origin-vault.mjs"
+    }
+  }
+}

package/record/index.d.ts

@@ -0,0 +1,81 @@
+import { AoObject, AoEntryUnion } from '@arabig/origin/types';
+
+/**
+ * @license
+ * Copyright Salar Arab All Rights Reserved.
+ *
+ * @author Salar Arab <salar_arab@outlook.com>
+ */
+
+/**
+ * Utilizes performing common operations as pipeline on object-like.
+ *
+ * @remarks
+ * {@link AoRecord} provides a fluent and type-safe API for manipulating objects.
+ * It includes methods for filtering, mapping, and transforming key-value pairs—similar to
+ * array utilities but designed for object semantics.
+ *
+ * This class is ideal for scenarios where object-based data structures need to be processed
+ * functionally, such as configuration maps, lookup tables, or DTO transformations.
+ *
+ * @typeParam T - The type of entries contained in the record.
+ *
+ * @example
+ * ```ts
+ * const rec = new AoRecord({
+ * name: "John",
+ * age: 33,
+ * married: false,
+ * }).filter(({ key }) => key !== "age");
+ * ```
+ */
+declare class AoRecord<T extends AoObject> {
+    private readonly _entries;
+    /**
+     *
+     * @param defaultEntries The default structure to initialize {@link AoRecord} entries
+     */
+    constructor(defaultEntries: T);
+    /**
+     * @readonly Gets keys of the current entries.
+     * @returns An array containing keys of the current entries
+     */
+    get keys(): (keyof T)[];
+    /**
+     * @readonly Gets values of the current entries.
+     * @returns An array containing values of the current entries
+     */
+    get values(): T[keyof T][];
+    /**
+     * @readonly Gets the current entries.
+     * @returns An array containing the current entries in form of {@link AoEntryUnion}
+     */
+    get entries(): AoEntryUnion<T>[];
+    /**
+     * Filters the current entries based on given condition.
+     * @param predicate The callback that iterates within {@link AoRecord} entries and
+     * provides the key and value in form of {@link AoEntryUnion} as parameter and must
+     * return a boolean type determines whether the current key should be remained in the
+     * resulting entries or not
+     * @returns A new instance of {@link AoRecord} containing the {@link Partial} filtered entries.
+     */
+    filter(predicate: (entry: AoEntryUnion<T>) => boolean): AoRecord<AoObject>;
+    /**
+     * Tests the trueness of the given condition for every entry.
+     * @param predicate The callback that iterates within {@link AoRecord} entries and
+     * provides the key and value in form of {@link AoEntryUnion} as parameter and must
+     * return a boolean type determines the condition for current entry
+     * @returns True, if the given conditions is true for every entry otherwise false
+     */
+    every(predicate: (entry: AoEntryUnion<T>) => boolean): boolean;
+    /**
+     * Tests the trueness of the given condition for atleast one entry.
+     * @param predicate The callback that iterates within {@link AoRecord} entries and
+     * provides the key and value in form of {@link AoEntryUnion} as parameter and must
+     * return a boolean type determines the condition for current entry
+     * @returns True, if the given conditions is true for atleast one entry otherwise false
+     */
+    some(predicate: (entry: AoEntryUnion<T>) => boolean): boolean;
+}
+
+export { AoRecord };