@medyll/idae-engine 1.0.0 → 1.1.0

package/README.md

@@ -1,122 +1,122 @@
-# @medyll/engine
-
-A powerful TypeScript library for data manipulation and operations across the idae-engine.
-
-## Installation
-
-Install the package using npm:
-
-```bash
-npm install @medyll/idae-engine
-```
-
-Or using yarn:
-
-```bash
-yarn add @medyll/idae-engine
-```
-
-## Usage
-
-The `@medyll/idae-eengine` package contains several utility classes. This section focuses on the `dataOp` class, which provides various data manipulation methods.
-
-### Importing
-
-```typescript
-import { dataOp } from '@medyll/idae-engine';
-```
-## dataOp
-### Methods
-
-#### do
-
-Performs a combination of sort, find, and group operations on data.
-
-```typescript
-const result = dataOp.do({
-  sort: { arr: myArray, by: 'fieldName', sort: 'asc' },
-  find: { arr: myArray, kw: 'searchTerm', field: 'fieldName' },
-  group: { dataList: myArray, groupBy: 'fieldName' }
-});
-```
-
-#### sortBy
-
-Sorts an array of objects based on specified fields.
-
-```typescript
-const sortedArray = dataOp.sortBy({
-  arr: myArray,
-  by: 'fieldName',
-  sort: 'asc'
-});
-```
-
-#### find
-
-Searches for objects in an array based on specified criteria.
-
-```typescript
-const foundItems = dataOp.find({
-  arr: myArray,
-  kw: 'searchTerm',
-  field: 'fieldName'
-});
-```
-
-#### findOne
-
-Searches for the first object in an array that matches the specified criteria.
-
-```typescript
-const foundItem = dataOp.findOne({
-  arr: myArray,
-  kw: 'searchTerm',
-  field: 'fieldName'
-});
-```
-
-#### groupBy
-
-Groups objects in an array based on specified fields or a custom grouping function.
-
-```typescript
-const groupedData = dataOp.groupBy({
-  dataList: myArray,
-  groupBy: 'fieldName'
-});
-```
-
-#### findByIndex
-
-Finds the index of an object in an array based on a specified key-value pair.
-
-```typescript
-const index = dataOp.findByIndex(myArray, 'value', 'keyName');
-```
-
-#### resolveDotPath
-
-Resolves a dot-notated path in an object.
-
-```typescript
-const value = dataOp.resolveDotPath(myObject, 'path.to.property');
-```
-
-### Testing
-
-The `dataOp` class comes with a comprehensive test suite. To run the tests:
-
-1. Clone the repository
-2. Install dependencies: `npm install` or `yarn install`
-3. Run tests: `npm test` or `yarn test`
-
-The tests cover various scenarios for each method, ensuring the reliability and correctness of the `dataOp` class.
-
-## Contributing
-
-Contributions are welcome! Please feel free to submit a Pull Request.
-
-## License
-
+# @medyll/engine
+
+A powerful TypeScript library for data manipulation and operations across the idae-engine.
+
+## Installation
+
+Install the package using npm:
+
+```bash
+npm install @medyll/idae-engine
+```
+
+Or using yarn:
+
+```bash
+yarn add @medyll/idae-engine
+```
+
+## Usage
+
+The `@medyll/idae-eengine` package contains several utility classes. This section focuses on the `dataOp` class, which provides various data manipulation methods.
+
+### Importing
+
+```typescript
+import { dataOp } from '@medyll/idae-engine';
+```
+## dataOp
+### Methods
+
+#### do
+
+Performs a combination of sort, find, and group operations on data.
+
+```typescript
+const result = dataOp.do({
+  sort: { arr: myArray, by: 'fieldName', sort: 'asc' },
+  find: { arr: myArray, kw: 'searchTerm', field: 'fieldName' },
+  group: { dataList: myArray, groupBy: 'fieldName' }
+});
+```
+
+#### sortBy
+
+Sorts an array of objects based on specified fields.
+
+```typescript
+const sortedArray = dataOp.sortBy({
+  arr: myArray,
+  by: 'fieldName',
+  sort: 'asc'
+});
+```
+
+#### find
+
+Searches for objects in an array based on specified criteria.
+
+```typescript
+const foundItems = dataOp.find({
+  arr: myArray,
+  kw: 'searchTerm',
+  field: 'fieldName'
+});
+```
+
+#### findOne
+
+Searches for the first object in an array that matches the specified criteria.
+
+```typescript
+const foundItem = dataOp.findOne({
+  arr: myArray,
+  kw: 'searchTerm',
+  field: 'fieldName'
+});
+```
+
+#### groupBy
+
+Groups objects in an array based on specified fields or a custom grouping function.
+
+```typescript
+const groupedData = dataOp.groupBy({
+  dataList: myArray,
+  groupBy: 'fieldName'
+});
+```
+
+#### findByIndex
+
+Finds the index of an object in an array based on a specified key-value pair.
+
+```typescript
+const index = dataOp.findByIndex(myArray, 'value', 'keyName');
+```
+
+#### resolveDotPath
+
+Resolves a dot-notated path in an object.
+
+```typescript
+const value = dataOp.resolveDotPath(myObject, 'path.to.property');
+```
+
+### Testing
+
+The `dataOp` class comes with a comprehensive test suite. To run the tests:
+
+1. Clone the repository
+2. Install dependencies: `npm install` or `yarn install`
+3. Run tests: `npm test` or `yarn test`
+
+The tests cover various scenarios for each method, ensuring the reliability and correctness of the `dataOp` class.
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
 This project is licensed under the MIT License.

package/dist/dataOp/dataOp.d.ts

@@ -1,66 +1,75 @@
-import { type ResolverPathType } from "./types.js";
-type Data = Record<string, any>;
-export type DataGroupResult<T> = {
+import { type ResolverPathType } from './types.js';
+export type DataOpGroupResult<T> = {
     [key: string]: {
         title: string;
         code?: string;
         data: T[];
     };
 };
-type DataSortBy<T> = {
+export type DataOpSortBy<T> = {
     arr: T[];
-    by: Partial<Record<ResolverPathType<T>, "asc" | "desc" | 1 | -1 | undefined>>;
+    by: Partial<Record<ResolverPathType<T>, 'asc' | 'desc' | 1 | -1 | undefined>>;
     options?: {
         keepRef: true;
     };
 } | {
     arr: T[];
     by: ResolverPathType<T> | ResolverPathType<T>[];
-    sort?: "asc" | "desc" | 1 | -1 | undefined;
+    sort?: 'asc' | 'desc' | 1 | -1 | undefined;
     options?: {
         keepRef: true;
     };
 };
-type DataFind<T> = {
+export type DataOpFind<T> = {
     kw: number | string;
     arr: T[];
-    field?: ResolverPathType<T> | "*";
+    field?: ResolverPathType<T> | '*';
     caseSensitive?: boolean;
     strict?: false;
 };
-type DataGroupBy<T> = {
+export type DataOpGroupBy<T> = {
     dataList: T[];
-    groupBy: ((item: T) => {
-        title: string;
-        code: string;
-    }) | ResolverPathType<T> | ResolverPathType<T>[];
+    groupBy: DataOpGroupByOptions<T>;
     keepUngroupedData?: boolean;
 };
+export type DataOpGroupByOptions<T> = ((item: T) => {
+    title: string;
+    code: string;
+}) | ResolverPathType<T> | ResolverPathType<T>[];
 /** data manipulation class */
 export declare class dataOp {
+    /**
+     * Get all keys of the objects in an array of objects.
+     * Keys are delimited by a dot.
+     *
+     * @template T - The type of objects in the array.
+     * @param {T[]} arr - The array of objects.
+     * @returns {string[]} An array of all keys.
+     */
+    static getDataKeys(arr: T[]): string[];
     /**
      * Performs a combination of sort, find, and group operations on data.
      *
      * @template T - The type of objects in the array, extends Data.
      * @param {Object} options - The options for data operations.
-     * @param {DataSortBy<T>} [options.sort] - Sorting options.
-     * @param {DataFind<T>} [options.find] - Finding options.
-     * @param {DataGroupBy<T>} [options.group] - Grouping options.
+     * @param {DataOpSortBy<T>} [options.sort] - Sorting options.
+     * @param {DataOpFind<T>} [options.find] - Finding options.
+     * @param {DataOpGroupBy<T>} [options.group] - Grouping options.
      * @returns {T[] | GroupResult<T>} The resulting array or grouped data.
      */
-    static do<T extends Data>(options: {
-        sort?: DataSortBy<T>;
-        find?: DataFind<T>;
-        group?: DataGroupBy<T>;
-    }): T[] | DataGroupResult<T>;
+    static do<T extends object>(options: {
+        sort?: DataOpSortBy<T>;
+        find?: DataOpFind<T>;
+        group?: DataOpGroupBy<T>;
+    }): T[] | DataOpGroupResult<T>;
     /**
      * Sorts an array of objects based on one or more specified fields with individual sort directions.
      *
      * @template T - The type of objects in the array, extends Data.
-     * @param {DataSortBy<T>} sortOptions - The sorting options.
+     * @param {DataOpSortBy<T>} sortOptions - The sorting options.
      * @returns {T[]} The sorted array.
      */
-    static sortBy<T extends Data>(sortOptions: DataSortBy<T>): T[];
+    static sortBy<T extends object>(sortOptions: DataOpSortBy<T>): T[];
     /**
      * Searches for objects in an array based on specified criteria.
      *
@@ -72,7 +81,7 @@ export declare class dataOp {
      * @param {boolean} [options.caseSensitive=false] - Whether the search should be case-sensitive.
      * @returns {T[]} An array of objects that match the search criteria.
      */
-    static find<T extends object = Record<string, unknown>>(options: DataFind<T>): T[];
+    static find<T extends object = Record<string, unknown>>(options: DataOpFind<T>): T[];
     /**
      * Searches for the first object in an array that matches the specified criteria.
      *
@@ -84,7 +93,7 @@ export declare class dataOp {
      * @param {boolean} [options.caseSensitive=false] - Whether the search should be case-sensitive.
      * @returns {T | undefined} The first object that matches the search criteria, or undefined if no match is found.
      */
-    static findOne<T extends Data>(options: DataFind<T>): T | undefined;
+    static findOne<T extends object>(options: DataOpFind<T>): T | undefined;
     /**
      * Groups objects in an array based on specified fields or a custom grouping function.
      *
@@ -93,9 +102,9 @@ export declare class dataOp {
      * @param {T[]} options.dataList - The array to group.
      * @param {((item: T) => { title: string; code: string }) | ResolverPathType<T> | ResolverPathType<T>[]} options.groupBy - The field(s) to group by or a function to determine the group.
      * @param {boolean} [options.keepUngroupedData=false] - Whether to keep ungrouped data.
-     * @returns {DataGroupResult<T>} An object where keys are group codes and values are objects containing title, code, and data array.
+     * @returns {DataOpGroupResult<T>} An object where keys are group codes and values are objects containing title, code, and data array.
      */
-    static groupBy<T = Data>(options: DataGroupBy<T>): DataGroupResult<T>;
+    static groupBy<T extends object>(options: DataOpGroupBy<T>): DataOpGroupResult<T>;
     /**
      *
      * @param arr array to find in
@@ -104,7 +113,7 @@ export declare class dataOp {
      * @returns number
      */
     static findByIndex<T = Record<string, any>>(arr: T[], value: any, key?: keyof T | ResolverPathType<T>): number;
-    static resolveDotPath<T = Data>(object: T, path: ResolverPathType<T>, defaultValue?: any): any;
+    static resolveDotPath<T>(object: T, path: ResolverPathType<T>, defaultValue?: any): any;
     /**
      * Compares two values for sorting.
      *
@@ -119,4 +128,3 @@ export declare class dataOp {
     private static compareValues;
     private static compareSearchValues;
 }
-export {};

package/dist/dataOp/dataOp.js

@@ -1,14 +1,41 @@
-import {} from "./types.js";
+import {} from './types.js';
 /** data manipulation class */
 export class dataOp {
+    /**
+     * Get all keys of the objects in an array of objects.
+     * Keys are delimited by a dot.
+     *
+     * @template T - The type of objects in the array.
+     * @param {T[]} arr - The array of objects.
+     * @returns {string[]} An array of all keys.
+     */
+    static getDataKeys(arr) {
+        const keys = new Set();
+        function addKeys(obj, prefix = '') {
+            for (const key in obj) {
+                if (Object.prototype.hasOwnProperty.call(obj, key)) {
+                    const fullKey = prefix ? `${prefix}.${key}` : key;
+                    keys.add(fullKey);
+                    if (typeof obj[key] === 'object' && obj[key] !== null) {
+                        addKeys(obj[key], fullKey);
+                    }
+                }
+            }
+        }
+        const limit = Math.min(arr.length, 100);
+        for (let i = 0; i < limit; i++) {
+            addKeys(arr[i]);
+        }
+        return Array.from(keys);
+    }
     /**
      * Performs a combination of sort, find, and group operations on data.
      *
      * @template T - The type of objects in the array, extends Data.
      * @param {Object} options - The options for data operations.
-     * @param {DataSortBy<T>} [options.sort] - Sorting options.
-     * @param {DataFind<T>} [options.find] - Finding options.
-     * @param {DataGroupBy<T>} [options.group] - Grouping options.
+     * @param {DataOpSortBy<T>} [options.sort] - Sorting options.
+     * @param {DataOpFind<T>} [options.find] - Finding options.
+     * @param {DataOpGroupBy<T>} [options.group] - Grouping options.
      * @returns {T[] | GroupResult<T>} The resulting array or grouped data.
      */
     static do(options) {
@@ -28,20 +55,19 @@ export class dataOp {
      * Sorts an array of objects based on one or more specified fields with individual sort directions.
      *
      * @template T - The type of objects in the array, extends Data.
-     * @param {DataSortBy<T>} sortOptions - The sorting options.
+     * @param {DataOpSortBy<T>} sortOptions - The sorting options.
      * @returns {T[]} The sorted array.
      */
     static sortBy(sortOptions) {
         const { arr, options } = sortOptions;
         const sortArray = options?.keepRef ? arr : [...arr];
-        if (!sortOptions.by ||
-            (Array.isArray(sortOptions.by) && sortOptions.by.length === 0)) {
+        if (!sortOptions.by || (Array.isArray(sortOptions.by) && sortOptions.by.length === 0)) {
             return sortArray;
         }
         return sortArray.sort((a, b) => {
-            if ("sort" in sortOptions) {
-                const { by, sort = "asc" } = sortOptions;
-                const sortD = sort === "asc" || sort === 1 ? 1 : -1;
+            if ('sort' in sortOptions) {
+                const { by, sort = 'asc' } = sortOptions;
+                const sortD = sort === 'asc' || sort === 1 ? 1 : -1;
                 const fields = Array.isArray(by) ? by : [by];
                 for (const field of fields) {
                     const comparison = this.compareValues(a, b, field, sortD);
@@ -51,7 +77,7 @@ export class dataOp {
             }
             else {
                 for (const [field, direction] of Object.entries(sortOptions.by)) {
-                    const sortD = direction === "asc" || Number(direction) === 1 ? 1 : -1;
+                    const sortD = direction === 'asc' || Number(direction) === 1 ? 1 : -1;
                     const comparison = this.compareValues(a, b, field, sortD);
                     if (comparison !== 0)
                         return comparison;
@@ -72,9 +98,9 @@ export class dataOp {
      * @returns {T[]} An array of objects that match the search criteria.
      */
     static find(options) {
-        const { arr, kw, field = "*", caseSensitive = false, strict = false, } = options;
+        const { arr, kw, field = '*', caseSensitive = false, strict = false } = options;
         return arr.filter((item) => {
-            if (field !== "*") {
+            if (field !== '*') {
                 const itemValue = this.resolveDotPath(item, field);
                 return this.compareSearchValues(itemValue, kw, caseSensitive, strict);
             }
@@ -93,9 +119,9 @@ export class dataOp {
      * @returns {T | undefined} The first object that matches the search criteria, or undefined if no match is found.
      */
     static findOne(options) {
-        const { arr, kw, field = "*", caseSensitive = false, strict = false, } = options;
+        const { arr, kw, field = '*', caseSensitive = false, strict = false } = options;
         return arr.find((item) => {
-            if (field !== "*") {
+            if (field !== '*') {
                 const itemValue = this.resolveDotPath(item, field);
                 return this.compareSearchValues(itemValue, kw, caseSensitive, strict);
             }
@@ -110,13 +136,13 @@ export class dataOp {
      * @param {T[]} options.dataList - The array to group.
      * @param {((item: T) => { title: string; code: string }) | ResolverPathType<T> | ResolverPathType<T>[]} options.groupBy - The field(s) to group by or a function to determine the group.
      * @param {boolean} [options.keepUngroupedData=false] - Whether to keep ungrouped data.
-     * @returns {DataGroupResult<T>} An object where keys are group codes and values are objects containing title, code, and data array.
+     * @returns {DataOpGroupResult<T>} An object where keys are group codes and values are objects containing title, code, and data array.
      */
     static groupBy(options) {
-        const { dataList, groupBy: groupField, keepUngroupedData = false, } = options;
+        const { dataList, groupBy: groupField, keepUngroupedData = false } = options;
         return dataList.reduce((result, currentItem) => {
             let groupInfo;
-            if (typeof groupField === "function") {
+            if (typeof groupField === 'function') {
                 groupInfo = groupField(currentItem);
             }
             else {
@@ -124,7 +150,7 @@ export class dataOp {
                 const groupValue = fields
                     .map((field) => this.resolveDotPath(currentItem, field))
                     .filter((value) => value !== undefined)
-                    .join(".");
+                    .join('.');
                 if (groupValue) {
                     groupInfo = { title: groupValue, code: groupValue };
                 }
@@ -132,14 +158,14 @@ export class dataOp {
             if (!groupInfo) {
                 if (!keepUngroupedData)
                     return result;
-                groupInfo = { title: "- Ungrouped", code: "- ungrouped" };
+                groupInfo = { title: '- Ungrouped', code: '- ungrouped' };
             }
             const groupKey = groupInfo.code;
             if (!result[groupKey]) {
                 result[groupKey] = {
                     title: groupInfo.title,
                     code: groupInfo.code,
-                    data: [],
+                    data: []
                 };
             }
             result[groupKey].data.push(currentItem);
@@ -153,13 +179,13 @@ export class dataOp {
      * @param key  object key to match with
      * @returns number
      */
-    static findByIndex(arr, value, key = "id") {
+    static findByIndex(arr, value, key = 'id') {
         return arr.findIndex((obj) => this.resolveDotPath(obj, key) === value);
     }
     static resolveDotPath(object, path, defaultValue) {
         return path
-            .split(".")
-            .reduce((r, s) => (r && typeof r === "object" && s in r ? r[s] : defaultValue), object);
+            .split('.')
+            .reduce((r, s) => (r && typeof r === 'object' && s in r ? r[s] : defaultValue), object);
     }
     /**
      * Compares two values for sorting.
@@ -175,7 +201,7 @@ export class dataOp {
     static compareValues(a, b, field, sortD) {
         const aValue = this.resolveDotPath(a, field);
         const bValue = this.resolveDotPath(b, field);
-        if (typeof aValue === "string" && typeof bValue === "string") {
+        if (typeof aValue === 'string' && typeof bValue === 'string') {
             return sortD * aValue.localeCompare(bValue);
         }
         return sortD * (aValue > bValue ? 1 : aValue < bValue ? -1 : 0);

package/package.json

@@ -1,46 +1,47 @@
-{
-	"name": "@medyll/idae-engine",
-	"scope": "@medyll",
-	"version": "1.0.0",
-	"scripts": {
-		"dev": "vite dev",
-		"build": "vite build && npm run package",
-		"preview": "vite preview",
-		"package": "svelte-kit sync && svelte-package && publint",
-		"package:watch": "svelte-kit sync && svelte-package --watch",
-		"prepublishOnly": "npm run package",
-		"check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
-		"check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
-		"test": "vitest"
-	},
-	"exports": {
-		".": {
-			"types": "./dist/index.d.ts",
-			"svelte": "./dist/index.js"
-		}
-	},
-	"files": [
-		"dist",
-		"!dist/**/*.test.*",
-		"!dist/**/*.spec.*"
-	],
-	"peerDependencies": {
-		"svelte": "^4.0.0"
-	},
-	"devDependencies": {
-		"@sveltejs/adapter-auto": "^3.0.0",
-		"@sveltejs/kit": "^2.0.0",
-		"@sveltejs/package": "^2.0.0",
-		"@sveltejs/vite-plugin-svelte": "^3.0.0",
-		"publint": "^0.1.9",
-		"svelte": "^5.0.0-next.183",
-		"svelte-check": "^3.6.0",
-		"tslib": "^2.4.1",
-		"typescript": "^5.0.0",
-		"vite": "^5.0.11",
-		"vitest": "^1.2.0"
-	},
-	"svelte": "./dist/index.js",
-	"types": "./dist/index.d.ts",
-	"type": "module"
-}
+{
+	"name": "@medyll/idae-engine",
+	"scope": "@medyll",
+	"version": "1.1.0",
+	"scripts": {
+		"dev": "vite dev",
+		"build": "vite build && npm run package",
+		"preview": "vite preview",
+		"package": "svelte-kit sync && svelte-package && publint",
+		"package:watch": "svelte-kit sync && svelte-package --watch",
+		"prepublishOnly": "npm run package",
+		"check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
+		"check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
+		"test": "vitest"
+	},
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"svelte": "./dist/index.js"
+		}
+	},
+	"files": [
+		"dist",
+		"!dist/**/*.test.*",
+		"!dist/**/*.spec.*"
+	],
+	"peerDependencies": {
+		"svelte": "^5.0.0-next.1"
+	},
+	"devDependencies": {
+		"@medyll/idae-prettier-config": "^1.0.0",
+		"@sveltejs/adapter-auto": "^3.0.0",
+		"@sveltejs/kit": "^2.0.0",
+		"@sveltejs/package": "^2.0.0",
+		"@sveltejs/vite-plugin-svelte": "^3.0.0",
+		"publint": "^0.1.9",
+		"svelte": "^5.0.0-next.183",
+		"svelte-check": "^3.6.0",
+		"tslib": "^2.4.1",
+		"typescript": "^5.0.0",
+		"vite": "^5.0.11",
+		"vitest": "^1.2.0"
+	},
+	"svelte": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"type": "module"
+}