@medyll/idae-engine 1.65.0 → 1.66.0

package/dist/dataOp/dataOp.d.ts

@@ -1,4 +1,4 @@
-import { type ResolverPathType } from './types.js';
+import { type ResolverPathType } from "./types.js";
 export type DataOpGroupResult<T> = {
     [key: string]: {
         title: string;
@@ -8,35 +8,68 @@ export type DataOpGroupResult<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;
     };
 };
+/**
+ * Represents the parameters for a data operation find function.
+ *
+ * @template T - The type of elements in the array.
+ *
+ * @property {number | string} kw - The keyword to search for in the array.
+ * @property {T[]} arr - The array of elements to search within.
+ * @property {ResolverPathType<T> | "*"} [field] - The field or path to search within each element. If not provided, the entire element is searched.
+ * @property {boolean} [caseSensitive] - Whether the search should be case-sensitive. Defaults to false.
+ * @property {false} [strict] - Whether the search should be strict. Defaults to false.
+ */
 export type DataOpFind<T> = {
+    /** keyword */
     kw: number | string;
     arr: T[];
-    field?: ResolverPathType<T> | '*';
+    field?: ResolverPathType<T> | "*";
     caseSensitive?: boolean;
     strict?: false;
 };
+/**
+ * Represents a data operation that groups a list of data items.
+ *
+ * @template T - The type of the data items in the list.
+ *
+ * @property {T[]} dataList - The list of data items to be grouped.
+ * @property {DataOpGroupByOptions<T>} groupBy - The options for grouping the data items.
+ * @property {boolean} [keepUngroupedData] - Optional flag indicating whether to keep ungrouped data items.
+ */
 export type DataOpGroupBy<T> = {
     dataList: T[];
     groupBy: DataOpGroupByOptions<T>;
     keepUngroupedData?: boolean;
 };
+/**
+ * Represents the options for grouping data operations.
+ *
+ * @template T - The type of the items being grouped.
+ *
+ * This type can be one of the following:
+ * - A function that takes an item of type `T` and returns an object with `title` and `code` properties.
+ * - A `ResolverPathType` of type `T`.
+ * - An array of `ResolverPathType` of type `T`.
+ */
 export type DataOpGroupByOptions<T> = ((item: T) => {
     title: string;
     code: string;
 }) | ResolverPathType<T> | ResolverPathType<T>[];
-/** data manipulation class */
+/**
+ * A class that provides various data operations such as getting keys, sorting, finding, and grouping objects in an array.
+ */
 export declare class dataOp {
     /**
      * Get all keys of the objects in an array of objects.
@@ -104,7 +137,7 @@ export declare class dataOp {
      * @param {boolean} [options.keepUngroupedData=false] - Whether to keep ungrouped data.
      * @returns {DataOpGroupResult<T>} An object where keys are group codes and values are objects containing title, code, and data array.
      */
-    static groupBy<T extends object>(options: DataOpGroupBy<T>): DataOpGroupResult<T>;
+    static groupBy<T>(options: DataOpGroupBy<T>): DataOpGroupResult<T>;
     /**
      *
      * @param arr array to find in

package/dist/dataOp/dataOp.js

@@ -1,5 +1,7 @@
-import {} from './types.js';
-/** data manipulation class */
+import {} from "./types.js";
+/**
+ * A class that provides various data operations such as getting keys, sorting, finding, and grouping objects in an array.
+ */
 export class dataOp {
     /**
      * Get all keys of the objects in an array of objects.
@@ -11,12 +13,12 @@ export class dataOp {
      */
     static getDataKeys(arr) {
         const keys = new Set();
-        function addKeys(obj, prefix = '') {
+        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) {
+                    if (typeof obj[key] === "object" && obj[key] !== null) {
                         addKeys(obj[key], fullKey);
                     }
                 }
@@ -61,13 +63,14 @@ export class dataOp {
     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);
@@ -77,7 +80,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;
@@ -98,9 +101,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);
             }
@@ -119,9 +122,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);
             }
@@ -139,10 +142,10 @@ export class dataOp {
      * @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 {
@@ -150,7 +153,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 };
                 }
@@ -158,14 +161,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);
@@ -179,13 +182,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.
@@ -201,7 +204,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,7 +1,7 @@
 {
 	"name": "@medyll/idae-engine",
 	"scope": "@medyll",
-	"version": "1.65.0",
+	"version": "1.66.0",
 	"description": "A powerful TypeScript library for data manipulation and operations across the idae-engine. Provides utility classes for sorting, finding, grouping, and more.",
 	"scripts": {
 		"dev": "vite dev",
@@ -31,18 +31,18 @@
 	},
 	"devDependencies": {
 		"@medyll/idae-prettier-config": "^1.1.0",
-		"@sveltejs/adapter-auto": "^3.2.2",
-		"@sveltejs/kit": "^2.5.20",
-		"@sveltejs/package": "^2.3.2",
-		"@sveltejs/vite-plugin-svelte": "^3.1.1",
-		"svelte": "^5.0.0-next.218",
-		"svelte-check": "^3.8.5",
-		"tslib": "^2.6.3",
+		"@sveltejs/adapter-auto": "^4.0.0",
+		"@sveltejs/kit": "^2.18.0",
+		"@sveltejs/package": "^2.3.10",
+		"@sveltejs/vite-plugin-svelte": "^5.0.3",
+		"svelte": "^5.22.4",
+		"svelte-check": "^4.1.4",
+		"tslib": "^2.8.1",
 		"typescript": "^5.8.2",
-		"vite": "^5.3.5",
-		"vitest": "^2.0.5"
+		"vite": "^6.2.0",
+		"vitest": "^3.0.7"
 	},
 	"svelte": "./dist/index.js",
 	"types": "./dist/index.d.ts",
 	"type": "module"
-}
+}