@leexi/shared 0.3.8 → 0.4.0

package/dist/eslint/vue.eslint.config.mjs

@@ -2,7 +2,7 @@ import tailwind from "eslint-plugin-tailwindcss";
 import tseslint from "typescript-eslint";
 import vue from "eslint-plugin-vue";
 import base from "./base.eslint.config.mjs";
-export default [
+const config = [
   ...base,
   ...tailwind.configs["flat/recommended"],
   ...vue.configs["flat/recommended"],
@@ -45,3 +45,4 @@ export default [
     ]
   }
 ];
+export default config;

package/dist/module.json

@@ -1,9 +1,9 @@
 {
   "configKey": "leexi",
   "name": "@leexi/shared",
-  "version": "0.3.8",
+  "version": "0.4.0",
   "builder": {
-    "@nuxt/module-builder": "1.0.1",
-    "unbuild": "3.5.0"
+    "@nuxt/module-builder": "1.0.2",
+    "unbuild": "3.6.1"
   }
 }

package/dist/runtime/utils/array/castArray.d.ts

@@ -0,0 +1 @@
+export function castArray(value: any): any[];

package/dist/runtime/utils/array/castArray.js

@@ -0,0 +1,3 @@
+import { deepDup } from '../index.js';
+
+export const castArray = value => Array.isArray(value) ? deepDup(value) : [value];

package/dist/runtime/utils/array/groupBy.d.ts

@@ -0,0 +1 @@
+export function groupBy(records: any, pathOrCallback: any): any;

package/dist/runtime/utils/array/groupBy.js

@@ -0,0 +1,9 @@
+import { get } from '../index.js';
+
+export const groupBy = (records, pathOrCallback) => records.reduce((groupedRecords, currentRecord) => {
+  const key = typeof pathOrCallback === 'string' ? get(currentRecord, pathOrCallback) : pathOrCallback(currentRecord);
+  groupedRecords[key] ||= [];
+  groupedRecords[key].push(currentRecord);
+
+  return groupedRecords;
+}, {});

package/dist/runtime/utils/array/index.d.ts

@@ -0,0 +1,11 @@
+export { castArray } from "./castArray.js";
+export { groupBy } from "./groupBy.js";
+export { joinBy } from "./joinBy.js";
+export { partition } from "./partition.js";
+export { removeRecord } from "./removeRecord.js";
+export { replaceRecord } from "./replaceRecord.js";
+export { sortBy } from "./sortBy.js";
+export { sum } from "./sum.js";
+export { sumBy } from "./sumBy.js";
+export { uniq } from "./uniq.js";
+export { uniqBy } from "./uniqBy.js";

package/dist/runtime/utils/array/index.js

@@ -0,0 +1,11 @@
+export { castArray } from './castArray.js';
+export { groupBy } from './groupBy.js';
+export { joinBy } from './joinBy.js';
+export { partition } from './partition.js';
+export { removeRecord } from './removeRecord.js';
+export { replaceRecord } from './replaceRecord.js';
+export { sortBy } from './sortBy.js';
+export { sum } from './sum.js';
+export { sumBy } from './sumBy.js';
+export { uniq } from './uniq.js';
+export { uniqBy } from './uniqBy.js';

package/dist/runtime/utils/array/joinBy.d.ts

@@ -0,0 +1 @@
+export function joinBy(records: any, attr: any): any[];

package/dist/runtime/utils/array/joinBy.js

@@ -0,0 +1,9 @@
+export const joinBy = (records, attr) => {
+  const filteredRecords = {};
+  records.forEach(record => {
+    const key = record[attr];
+    return filteredRecords[key] = { ...filteredRecords[key], ...record };
+  });
+
+  return Object.values(filteredRecords);
+};

package/dist/runtime/utils/array/partition.d.ts

@@ -0,0 +1 @@
+export function partition(items: any, callback: any): any;

package/dist/runtime/utils/array/partition.js

@@ -0,0 +1,4 @@
+export const partition = (items, callback) => items.reduce(([truthy, falsy], currentItem) => {
+  (callback(currentItem) ? truthy : falsy).push(currentItem);
+  return [truthy, falsy];
+}, [[], []]);

package/dist/runtime/utils/array/removeRecord.d.ts

@@ -0,0 +1 @@
+export function removeRecord(records: any, removedRecord: any, removeBy?: string): any;

package/dist/runtime/utils/array/removeRecord.js

@@ -0,0 +1,3 @@
+export const removeRecord = (records, removedRecord, removeBy = 'uuid') => (
+  records.filter(record => record[removeBy] !== removedRecord[removeBy])
+);

package/dist/runtime/utils/array/replaceRecord.d.ts

@@ -0,0 +1 @@
+export function replaceRecord(records: any, replacement: any, replaceBy?: string): any;

package/dist/runtime/utils/array/replaceRecord.js

@@ -0,0 +1,3 @@
+export const replaceRecord = (records, replacement, replaceBy = 'uuid') => (
+  records.map(record => record[replaceBy] === replacement[replaceBy] ? replacement : record)
+);

package/dist/runtime/utils/array/sortBy.d.ts

@@ -0,0 +1,2 @@
+import type { FilteredAttrs, Primitive } from '~/types';
+export declare const sortBy: <T, C extends (_: T) => Primitive, K extends Extract<FilteredAttrs<T, Primitive>, string>>(items: T[], attrsOrCallbacks: C | K | `-${K}` | (C | K | `-${K}`)[]) => T[];

package/dist/runtime/utils/array/sortBy.js

@@ -0,0 +1,40 @@
+import { deepDup } from "~/src/runtime/utils";
+export const sortBy = (items, attrsOrCallbacks) => {
+  const directions = [];
+  if (!Array.isArray(attrsOrCallbacks)) {
+    attrsOrCallbacks = [attrsOrCallbacks];
+  }
+  const formattedAttrsOrCallbacks = attrsOrCallbacks.map((attrOrCallback, index) => {
+    if (typeof attrOrCallback === "string" && attrOrCallback[0] === "-") {
+      directions[index] = -1;
+      return attrOrCallback.slice(1);
+    } else {
+      directions[index] = 1;
+      return attrOrCallback;
+    }
+  });
+  const getValue = (item, index) => {
+    const attrOrCallback = formattedAttrsOrCallbacks[index];
+    if (typeof attrOrCallback === "string") {
+      return item[attrOrCallback];
+    } else if (typeof attrOrCallback === "function") {
+      return attrOrCallback(item);
+    } else {
+      return 0;
+    }
+  };
+  return deepDup(items).sort((a, b) => {
+    for (let i = 0; i < formattedAttrsOrCallbacks.length; i++) {
+      const aValue = getValue(a, i);
+      const bValue = getValue(b, i);
+      if (typeof aValue === "string" && typeof bValue === "string" && aValue.localeCompare(bValue) !== 0) {
+        return aValue.localeCompare(bValue) > 0 ? directions[i] : -directions[i];
+      } else if (typeof aValue === "number" && typeof bValue === "number" && aValue !== bValue) {
+        return (aValue - bValue) * directions[i];
+      } else if (typeof aValue === "boolean" && aValue !== bValue) {
+        return aValue ? directions[i] : -directions[i];
+      }
+    }
+    return 0;
+  });
+};

package/dist/runtime/utils/array/sum.d.ts

@@ -0,0 +1 @@
+export function sum(numbers: any): any;

package/dist/runtime/utils/array/sum.js

@@ -0,0 +1 @@
+export const sum = numbers => numbers.reduce((a, b) => a + b, 0);

package/dist/runtime/utils/array/sumBy.d.ts

@@ -0,0 +1 @@
+export function sumBy(records: any, attr: any): any;

package/dist/runtime/utils/array/sumBy.js

@@ -0,0 +1,3 @@
+import { sum } from '../index.js';
+
+export const sumBy = (records, attr) => sum(records.map(record => record[attr]));

package/dist/runtime/utils/array/uniq.d.ts

@@ -0,0 +1 @@
+export function uniq(values: any): any[];

package/dist/runtime/utils/array/uniq.js

@@ -0,0 +1 @@
+export const uniq = values => [...new Set(values || [])];

package/dist/runtime/utils/array/uniqBy.d.ts

@@ -0,0 +1 @@
+export function uniqBy(records: any, attrOrCallback: any): any[];

package/dist/runtime/utils/array/uniqBy.js

@@ -0,0 +1,8 @@
+export const uniqBy = (records, attrOrCallback) => {
+  const mapData = records.map(record => {
+    const key = typeof attrOrCallback === 'string' ? record[attrOrCallback] : attrOrCallback(record);
+    return [key, record];
+  });
+
+  return [...new Map(mapData).values()];
+};

package/dist/runtime/utils/function/debounce.d.ts

@@ -0,0 +1 @@
+export function debounce(callback: any, timeout?: number): void;

package/dist/runtime/utils/function/debounce.js

@@ -0,0 +1,6 @@
+let timer;
+
+export const debounce = (callback, timeout = 300) => {
+  clearTimeout(timer);
+  timer = setTimeout(callback, timeout);
+};

package/dist/runtime/utils/function/index.d.ts

@@ -0,0 +1 @@
+export { debounce } from "./debounce.js";

package/dist/runtime/utils/function/index.js

@@ -0,0 +1 @@
+export { debounce } from './debounce.js';

package/dist/runtime/utils/index.d.ts

@@ -1,3 +1,7 @@
+export * from './array/index.js';
+export * from './function/index.js';
+export * from './number/index.js';
 export * from './objects/index.js';
+export * from './promise/index.js';
 export * from './records/index.js';
 export * from './strings/index.js';

package/dist/runtime/utils/index.js

@@ -1,3 +1,7 @@
+export * from "./array/index.js";
+export * from "./function/index.js";
+export * from "./number/index.js";
 export * from "./objects/index.js";
+export * from "./promise/index.js";
 export * from "./records/index.js";
 export * from "./strings/index.js";

package/dist/runtime/utils/number/index.d.ts

@@ -0,0 +1 @@
+export { toPadStart } from "./toPadStart.js";

package/dist/runtime/utils/number/index.js

@@ -0,0 +1 @@
+export { toPadStart } from './toPadStart.js';

package/dist/runtime/utils/number/toPadStart.d.ts

@@ -0,0 +1 @@
+export function toPadStart(value: any, maxLength?: number, fillString?: string): string;

package/dist/runtime/utils/number/toPadStart.js

@@ -0,0 +1,3 @@
+export const toPadStart = (value, maxLength = 2, fillString = '0') => (
+  Math.floor(value).toString().padStart(maxLength, fillString)
+);

package/dist/runtime/utils/promise/index.d.ts

@@ -0,0 +1,3 @@
+export { singleFlight } from "./singleFlight.js";
+export { sleep } from "./sleep.js";
+export { throttle } from "./throttle.js";

package/dist/runtime/utils/promise/index.js

@@ -0,0 +1,3 @@
+export { singleFlight } from './singleFlight.js';
+export { sleep } from './sleep.js';
+export { throttle } from './throttle.js';

package/dist/runtime/utils/promise/singleFlight.d.ts

@@ -0,0 +1 @@
+export function singleFlight(key: string, request: () => Promise<any>): Promise<any>;

package/dist/runtime/utils/promise/singleFlight.js

@@ -0,0 +1,32 @@
+const cachedPromise = {};
+
+/**
+ * Ensures that a given asynchronous `request` function, identified by a `key`,
+ * is executed only once, even if called multiple times concurrently. Subsequent
+ * calls with the same key will return the same Promise as the initial call,
+ * preventing redundant operations.
+ *
+ * The cached Promise for a specific key is cleared once the request
+ * (either successfully or with an error) has completed. This allows
+ * for subsequent calls with the same key to trigger a new request.
+ *
+ * @param {string} key - A unique identifier for the request.
+ * @param {function(): Promise<any>} request - An asynchronous function that
+ * returns a Promise. This function will be executed only if there is
+ * no ongoing request for the given `key`.
+ * @returns {Promise<any>} A Promise that resolves with the result of the
+ * `request` function, or rejects with its error. All concurrent calls
+ * for the same `key` will receive this same Promise.
+ */
+export const singleFlight = (key, request) => {
+  if (!cachedPromise[key]) {
+    cachedPromise[key] = new Promise((resolve, reject) => {
+      request()
+        .then(response => { resolve(response); })
+        .catch(error => { reject(error); })
+        .finally(() => { cachedPromise[key] = null; });
+    });
+  }
+
+  return cachedPromise[key];
+};

package/dist/runtime/utils/promise/sleep.d.ts

@@ -0,0 +1 @@
+export function sleep(msDuration: any): Promise<any>;

package/dist/runtime/utils/promise/sleep.js

@@ -0,0 +1 @@
+export const sleep = msDuration => new Promise(resolve => setTimeout(resolve, msDuration));

package/dist/runtime/utils/promise/throttle.d.ts

@@ -0,0 +1 @@
+export function throttle(promises: any, max: any, abortController?: AbortController): Promise<(AbortController | (() => Promise<any[]>))[]>;

package/dist/runtime/utils/promise/throttle.js

@@ -0,0 +1,32 @@
+export const throttle = async (promises, max, abortController = new AbortController()) => {
+  const handlePromises = async () => {
+    const queue = new Set();
+    const results = [];
+
+    for (const promise of promises) {
+      if (abortController.signal.aborted) {
+        await Promise.all(queue); // Wait for the promises in the queue to finish
+        throw new Error('Aborted');
+      }
+
+      const p = promise().then(response => {
+        queue.delete(p);
+        return response;
+      });
+
+      queue.add(p);
+      results.push(p);
+
+      if (queue.size >= max) { await Promise.race(queue); }
+    }
+
+    abortController.signal.addEventListener('abort', async () => {
+      await Promise.all(queue); // Wait for the promises in the queue to finish
+      queue.forEach(p => p.abort());
+    });
+
+    return Promise.all(results);
+  };
+
+  return [handlePromises, abortController];
+};

package/dist/runtime/utils/records/get.d.ts

@@ -0,0 +1 @@
+export function get(record: any, path: any): any;

package/dist/runtime/utils/records/get.js

@@ -0,0 +1,5 @@
+export const get = (record, path) => {
+  let value = record;
+  path.split('.').forEach(key => value = value?.[key]);
+  return value;
+};

package/dist/runtime/utils/records/index.d.ts

@@ -1,3 +1,5 @@
+export { get } from './get.js';
+export { merge } from './merge.js';
 export { omit } from './omit.js';
 export { pick } from './pick.js';
 export { set } from './set.js';

package/dist/runtime/utils/records/index.js

@@ -1,3 +1,5 @@
+export { get } from "./get.js";
+export { merge } from "./merge.js";
 export { omit } from "./omit.js";
 export { pick } from "./pick.js";
 export { set } from "./set.js";

package/dist/runtime/utils/records/merge.d.ts

@@ -0,0 +1 @@
+export function merge(record: any, defaults: any): any;

package/dist/runtime/utils/records/merge.js

@@ -0,0 +1,16 @@
+import { deepDup } from '../index.js';
+
+export const merge = (record, defaults) => {
+  const dup = deepDup(record || {});
+  Object.entries(defaults || {}).forEach(([key, value]) => {
+    const isObject = value && typeof value === 'object' && !Array.isArray(value);
+
+    if (isObject) {
+      dup[key] = merge(dup[key], value);
+    } else if (dup[key] == null) {
+      dup[key] = value;
+    }
+  });
+
+  return dup;
+};

package/dist/runtime/utils/records/set.js

@@ -1,5 +1,7 @@
 export const set = (record, path, value) => {
-  const [key, ...rest] = path;
-  Object.assign(record, { ...record, [key]: rest.length ? set(record[key] ?? {}, rest, value) : value });
+  if (path.length) {
+    const [key, ...rest] = path;
+    Object.assign(record, { ...record, [key]: rest.length ? set(record[key] ?? {}, rest, value) : value });
+  }
   return record;
 };

package/dist/runtime/utils/strings/index.d.ts

@@ -2,3 +2,6 @@ export { camelcase } from './camelcase.js';
 export { capitalize } from './capitalize.js';
 export { kebabcase } from './kebabcase.js';
 export { snakecase } from './snakecase.js';
+export { strContains } from './strContains.js';
+export { truncate } from './truncate.js';
+export { urlify } from './urlify.js';

package/dist/runtime/utils/strings/index.js

@@ -2,3 +2,6 @@ export { camelcase } from "./camelcase.js";
 export { capitalize } from "./capitalize.js";
 export { kebabcase } from "./kebabcase.js";
 export { snakecase } from "./snakecase.js";
+export { strContains } from "./strContains.js";
+export { truncate } from "./truncate.js";
+export { urlify } from "./urlify.js";

package/dist/runtime/utils/strings/strContains.d.ts

@@ -0,0 +1 @@
+export function strContains(value: any, query: any, options?: {}): any;

package/dist/runtime/utils/strings/strContains.js

@@ -0,0 +1,18 @@
+export const strContains = (value, query, options = {}) => {
+  const deaccent = string => string.normalize('NFD').replace(/\p{Diacritic}/gu, '');
+
+  value ||= '';
+  query ||= '';
+
+  if (!options.caseSensitive) {
+    value = value.toLowerCase();
+    query = query.toLowerCase();
+  }
+
+  if (!options.accentSensitive) {
+    value = deaccent(value);
+    query = deaccent(query);
+  }
+
+  return value.includes(query);
+};

package/dist/runtime/utils/strings/truncate.d.ts

@@ -0,0 +1 @@
+export function truncate(value: any, precision: any, overflow?: string): any;

package/dist/runtime/utils/strings/truncate.js

@@ -0,0 +1,5 @@
+export const truncate = (value, precision, overflow = '...') => {
+  if (typeof value !== 'string') { return value; }
+
+  return value.length > precision ? `${value.slice(0, precision)}${overflow}` : value;
+};

package/dist/runtime/utils/strings/urlify.d.ts

@@ -0,0 +1 @@
+export function urlify(endpoint: any, params: any): string;

package/dist/runtime/utils/strings/urlify.js

@@ -0,0 +1 @@
+export const urlify = (endpoint, params) => `${endpoint}?${new URLSearchParams(params).toString()}`;

package/package.json

@@ -2,7 +2,7 @@
   "license": "UNLICENSED",
   "name": "@leexi/shared",
   "type": "module",
-  "version": "0.3.8",
+  "version": "0.4.0",
   "exports": {
     "./composables": {
       "import": "./dist/runtime/composables/index.js",
@@ -46,24 +46,25 @@
     "tsc": "vue-tsc --noEmit"
   },
   "dependencies": {
-    "@stylistic/eslint-plugin": "^5.1.0",
+    "@stylistic/eslint-plugin": "^5.2.3",
     "@types/eslint-plugin-tailwindcss": "^3.17.0",
-    "eslint": "^9.30.0",
-    "eslint-plugin-tailwindcss": "^3.18.0",
-    "eslint-plugin-vue": "^10.2.0",
-    "globals": "^16.2.0",
-    "typescript": "^5.8.3",
-    "typescript-eslint": "^8.35.1",
+    "eslint": "^9.34.0",
+    "eslint-plugin-sort-keys-plus": "^1.5.0",
+    "eslint-plugin-tailwindcss": "^3.18.2",
+    "eslint-plugin-vue": "^10.4.0",
+    "globals": "^16.3.0",
+    "typescript": "^5.9.2",
+    "typescript-eslint": "^8.41.0",
     "vue-eslint-parser": "^10.2.0"
   },
   "devDependencies": {
-    "@nuxt/module-builder": "^1.0.1",
+    "@nuxt/module-builder": "^1.0.2",
     "@nuxt/test-utils": "^3.19.2",
-    "@types/node": "^22.16.0",
+    "@types/node": "<23.0.0",
     "happy-dom": "^18.0.1",
-    "nuxt": "^3.17.6",
+    "nuxt": "^4.0.3",
     "tailwindcss": "<4.0.0",
     "vitest": "^3.2.4",
-    "vue-tsc": "^2.2.10"
+    "vue-tsc": "^3.0.6"
   }
 }