@lisergia/utilities 23.0.0 → 25.0.0

package/dist/Canvas.d.ts

@@ -0,0 +1,5 @@
+declare function trim(canvas: HTMLCanvasElement): HTMLCanvasElement;
+export declare const CanvasUtils: {
+    trim: typeof trim;
+};
+export {};

package/dist/Canvas.js

@@ -0,0 +1,51 @@
+function trim(canvas) {
+    const context = canvas.getContext('2d');
+    const copy = document.createElement('canvas').getContext('2d', { willReadFrequently: true });
+    const pixels = context.getImageData(0, 0, canvas.width, canvas.height);
+    const length = pixels.data.length;
+    const bound = {
+        bottom: null,
+        left: null,
+        right: null,
+        top: null,
+    };
+    let x;
+    let y;
+    for (let i = 0; i < length; i += 4) {
+        if (pixels.data[i + 3] !== 0) {
+            x = (i / 4) % canvas.width;
+            y = ~~(i / 4 / canvas.width);
+            if (bound.top === null) {
+                bound.top = y;
+            }
+            if (bound.left === null) {
+                bound.left = x;
+            }
+            else if (x < bound.left) {
+                bound.left = x;
+            }
+            if (bound.right === null) {
+                bound.right = x;
+            }
+            else if (bound.right < x) {
+                bound.right = x;
+            }
+            if (bound.bottom === null) {
+                bound.bottom = y;
+            }
+            else if (bound.bottom < y) {
+                bound.bottom = y;
+            }
+        }
+    }
+    const trimHeight = bound.bottom - bound.top;
+    const trimWidth = bound.right - bound.left;
+    const trimmed = context.getImageData(bound.left, bound.top, trimWidth, trimHeight);
+    copy.canvas.width = trimWidth;
+    copy.canvas.height = trimHeight;
+    copy.putImageData(trimmed, 0, 0);
+    return copy.canvas;
+}
+export const CanvasUtils = {
+    trim,
+};

package/dist/DOM.d.ts

@@ -0,0 +1,12 @@
+export interface DOMRectBounds {
+    bottom: number;
+    height: number;
+    left: number;
+    top: number;
+    width: number;
+}
+declare function getBounds(element: HTMLElement, top?: number): DOMRectBounds;
+export declare const DOMUtils: {
+    getBounds: typeof getBounds;
+};
+export {};

package/dist/DOM.js

@@ -0,0 +1,13 @@
+function getBounds(element, top = 0) {
+    const box = element.getBoundingClientRect();
+    return {
+        bottom: box.bottom,
+        height: box.height,
+        left: box.left,
+        top: box.top + top,
+        width: box.width,
+    };
+}
+export const DOMUtils = {
+    getBounds,
+};

package/dist/Detection.d.ts

@@ -0,0 +1,4 @@
+export declare class DetectionManager {
+    isMobile(): boolean;
+}
+export declare const Detection: DetectionManager;

package/dist/Detection.js

@@ -0,0 +1,6 @@
+export class DetectionManager {
+    isMobile() {
+        return !document.documentElement.classList.contains('desktop');
+    }
+}
+export const Detection = new DetectionManager();

package/dist/Math.d.ts

@@ -0,0 +1,11 @@
+declare function lerp(start: number, end: number, time: number): number;
+declare function clamp(value: number, min: number, max: number): number;
+declare function random(min: number, max: number): number;
+declare function map(value: number, inMin: number, inMax: number, outMin: number, outMax: number, clamp?: boolean): number;
+export declare const MathUtils: {
+    clamp: typeof clamp;
+    lerp: typeof lerp;
+    map: typeof map;
+    random: typeof random;
+};
+export {};

package/dist/Math.js

@@ -0,0 +1,23 @@
+function lerp(start, end, time) {
+    return start + (end - start) * time;
+}
+function clamp(value, min, max) {
+    return Math.min(Math.max(value, min), max);
+}
+function random(min, max) {
+    return Math.random() * (max - min) + min;
+}
+function map(value, inMin, inMax, outMin, outMax, clamp = false) {
+    let mapped = ((value - inMin) * (outMax - outMin)) / (inMax - inMin) + outMin;
+    if (clamp) {
+        const [minOut, maxOut] = outMin < outMax ? [outMin, outMax] : [outMax, outMin];
+        mapped = Math.min(Math.max(mapped, minOut), maxOut);
+    }
+    return mapped;
+}
+export const MathUtils = {
+    clamp,
+    lerp,
+    map,
+    random,
+};

package/dist/Polyfill.d.ts

@@ -0,0 +1,17 @@
+type HTMLElementForEach = (this: HTMLElement, callback: (value: HTMLElement, key: HTMLElement, parent: HTMLElement) => void, thisArg?: unknown) => void;
+declare interface HTMLElement {
+    forEach: HTMLElementForEach;
+}
+declare interface NodeList {
+    filter: typeof Array.prototype.filter;
+    find: typeof Array.prototype.find;
+    map: typeof Array.prototype.map;
+}
+declare const HTMLElementPrototype: {
+    forEach: HTMLElementForEach;
+};
+declare const NodeListPrototype: {
+    filter: typeof Array.prototype.filter;
+    find: typeof Array.prototype.find;
+    map: typeof Array.prototype.map;
+};

package/dist/Polyfill.js

@@ -0,0 +1,29 @@
+"use strict";
+const HTMLElementPrototype = HTMLElement.prototype;
+const NodeListPrototype = NodeList.prototype;
+/**
+ * Allow `forEach` to work with single HTMLElement.
+ */
+if (!HTMLElementPrototype.forEach) {
+    HTMLElementPrototype.forEach = function (callback, thisArg) {
+        callback.call(thisArg ?? window, this, this, this);
+    };
+}
+/**
+ * Allow `filter` to work with NodeList.
+ */
+if (!NodeListPrototype.filter) {
+    NodeListPrototype.filter = Array.prototype.filter;
+}
+/**
+ * Allow `find` to work with NodeList.
+ */
+if (!NodeListPrototype.find) {
+    NodeListPrototype.find = Array.prototype.find;
+}
+/**
+ * Allow `map` to work with NodeList.
+ */
+if (!NodeListPrototype.map) {
+    NodeListPrototype.map = Array.prototype.map;
+}

package/dist/Promises.d.ts

@@ -0,0 +1,3 @@
+export declare const createPromise: <T>() => [Promise<T>, (value: T) => void];
+export declare const createPromiseWithReject: <T>() => [Promise<T>, (value: T) => void, (reason?: unknown) => void];
+export declare const createPromiseWithTimeout: <T>(timeout: number) => [Promise<T>, (value: T) => void, (reason?: unknown) => void];

package/dist/Promises.js

@@ -0,0 +1,31 @@
+export const createPromise = () => {
+    let resolve;
+    const promise = new Promise((resolvePromise) => {
+        resolve = resolvePromise;
+    });
+    return [promise, resolve];
+};
+export const createPromiseWithReject = () => {
+    let resolve;
+    let reject;
+    const promise = new Promise((resolvePromise, rejectPromise) => {
+        resolve = resolvePromise;
+        reject = rejectPromise;
+    });
+    return [promise, resolve, reject];
+};
+export const createPromiseWithTimeout = (timeout) => {
+    let resolve;
+    let reject;
+    const promise = new Promise((resolvePromise, rejectPromise) => {
+        resolve = resolvePromise;
+        reject = rejectPromise;
+    });
+    const timer = setTimeout(() => {
+        reject(new Error('Promise timed out'));
+    }, timeout);
+    promise.finally(() => {
+        clearTimeout(timer);
+    });
+    return [promise, resolve, reject];
+};

package/dist/Tempus.d.ts

@@ -0,0 +1,7 @@
+import { type TempusCallback, type TempusOptions } from 'tempus';
+export declare class TempusUtilsManager {
+    cache: Map<any, any>;
+    add(callback: TempusCallback, options?: TempusOptions): void;
+    remove(callback: TempusCallback): void;
+}
+export declare const TempusUtils: TempusUtilsManager;

package/dist/Tempus.js

@@ -0,0 +1,16 @@
+import Tempus from 'tempus';
+export class TempusUtilsManager {
+    cache = new Map();
+    add(callback, options) {
+        const cancel = Tempus.add(callback, options);
+        this.cache.set(callback, cancel);
+    }
+    remove(callback) {
+        const cancel = this.cache.get(callback);
+        if (cancel) {
+            cancel();
+            this.cache.delete(callback);
+        }
+    }
+}
+export const TempusUtils = new TempusUtilsManager();

package/dist/index.d.ts

@@ -1,43 +1,6 @@
-import { TempusCallback, TempusOptions } from 'tempus';
-
-declare function trim(canvas: HTMLCanvasElement): HTMLCanvasElement;
-declare const CanvasUtils: {
-    trim: typeof trim;
-};
-
-declare class DetectionManager {
-    isMobile(): boolean;
-}
-declare const Detection: DetectionManager;
-
-interface DOMRectBounds {
-    bottom: number;
-    height: number;
-    left: number;
-    top: number;
-    width: number;
-}
-declare function getBounds(element: HTMLElement, top?: number): DOMRectBounds;
-declare const DOMUtils: {
-    getBounds: typeof getBounds;
-};
-
-declare function lerp(start: number, end: number, time: number): number;
-declare function clamp(value: number, min: number, max: number): number;
-declare function random(min: number, max: number): number;
-declare function map(value: number, inMin: number, inMax: number, outMin: number, outMax: number, clamp?: boolean): number;
-declare const MathUtils: {
-    clamp: typeof clamp;
-    lerp: typeof lerp;
-    map: typeof map;
-    random: typeof random;
-};
-
-declare class TempusUtilsManager {
-    cache: Map<any, any>;
-    add(callback: TempusCallback, options?: TempusOptions): void;
-    remove(callback: TempusCallback): void;
-}
-declare const TempusUtils: TempusUtilsManager;
-
-export { CanvasUtils, type DOMRectBounds, DOMUtils, Detection, DetectionManager, MathUtils, TempusUtils, TempusUtilsManager };
+import './Polyfill.js';
+export * from './Canvas.js';
+export * from './Detection.js';
+export * from './DOM.js';
+export * from './Math.js';
+export * from './Tempus.js';

package/dist/index.js

@@ -1,246 +1,6 @@
-// src/Polyfill.ts
-var HTMLElementPrototype = HTMLElement.prototype;
-var NodeListPrototype = NodeList.prototype;
-if (!HTMLElementPrototype.forEach) {
-  HTMLElementPrototype.forEach = function(callback, thisArg) {
-    thisArg = thisArg || window;
-    callback.call(thisArg, this, this, this);
-  };
-}
-if (!NodeListPrototype.filter) {
-  NodeListPrototype.filter = Array.prototype.filter;
-}
-if (!NodeListPrototype.find) {
-  NodeListPrototype.find = Array.prototype.find;
-}
-if (!NodeListPrototype.map) {
-  NodeListPrototype.map = Array.prototype.map;
-}
-
-// src/Canvas.ts
-function trim(canvas) {
-  const context = canvas.getContext("2d");
-  const copy = document.createElement("canvas").getContext("2d", { willReadFrequently: true });
-  const pixels = context.getImageData(0, 0, canvas.width, canvas.height);
-  const length = pixels.data.length;
-  const bound = {
-    bottom: null,
-    left: null,
-    right: null,
-    top: null
-  };
-  let x;
-  let y;
-  for (let i = 0; i < length; i += 4) {
-    if (pixels.data[i + 3] !== 0) {
-      x = i / 4 % canvas.width;
-      y = ~~(i / 4 / canvas.width);
-      if (bound.top === null) {
-        bound.top = y;
-      }
-      if (bound.left === null) {
-        bound.left = x;
-      } else if (x < bound.left) {
-        bound.left = x;
-      }
-      if (bound.right === null) {
-        bound.right = x;
-      } else if (bound.right < x) {
-        bound.right = x;
-      }
-      if (bound.bottom === null) {
-        bound.bottom = y;
-      } else if (bound.bottom < y) {
-        bound.bottom = y;
-      }
-    }
-  }
-  const trimHeight = bound.bottom - bound.top;
-  const trimWidth = bound.right - bound.left;
-  const trimmed = context.getImageData(bound.left, bound.top, trimWidth, trimHeight);
-  copy.canvas.width = trimWidth;
-  copy.canvas.height = trimHeight;
-  copy.putImageData(trimmed, 0, 0);
-  return copy.canvas;
-}
-var CanvasUtils = {
-  trim
-};
-
-// src/Detection.ts
-var DetectionManager = class {
-  isMobile() {
-    return !document.documentElement.classList.contains("desktop");
-  }
-};
-var Detection = new DetectionManager();
-
-// src/DOM.ts
-function getBounds(element, top = 0) {
-  const box = element.getBoundingClientRect();
-  return {
-    bottom: box.bottom,
-    height: box.height,
-    left: box.left,
-    top: box.top + top,
-    width: box.width
-  };
-}
-var DOMUtils = {
-  getBounds
-};
-
-// src/Math.ts
-function lerp(start, end, time) {
-  return start + (end - start) * time;
-}
-function clamp(value, min, max) {
-  return Math.min(Math.max(value, min), max);
-}
-function random(min, max) {
-  return Math.random() * (max - min) + min;
-}
-function map(value, inMin, inMax, outMin, outMax, clamp2 = false) {
-  let mapped = (value - inMin) * (outMax - outMin) / (inMax - inMin) + outMin;
-  if (clamp2) {
-    const [minOut, maxOut] = outMin < outMax ? [outMin, outMax] : [outMax, outMin];
-    mapped = Math.min(Math.max(mapped, minOut), maxOut);
-  }
-  return mapped;
-}
-var MathUtils = {
-  clamp,
-  lerp,
-  map,
-  random
-};
-
-// ../../node_modules/tempus/dist/tempus.mjs
-var index = 0;
-function getUID() {
-  return index++;
-}
-var isClient = typeof window !== "undefined";
-var originalRAF = isClient && window.requestAnimationFrame;
-var originalCancelRAF = isClient && window.cancelAnimationFrame;
-var Framerate = class {
-  callbacks;
-  fps;
-  time;
-  lastTickDate;
-  constructor(fps = Number.POSITIVE_INFINITY) {
-    this.callbacks = [];
-    this.fps = fps;
-    this.time = 0;
-    this.lastTickDate = performance.now();
-  }
-  get executionTime() {
-    return 1e3 / this.fps;
-  }
-  dispatch(time, deltaTime) {
-    var _a;
-    for (let i = 0; i < this.callbacks.length; i++) {
-      (_a = this.callbacks[i]) == null ? void 0 : _a.callback(time, deltaTime);
-    }
-  }
-  raf(time, deltaTime) {
-    this.time += deltaTime;
-    if (this.fps === Number.POSITIVE_INFINITY) {
-      this.dispatch(time, deltaTime);
-    } else if (this.time >= this.executionTime) {
-      this.time = this.time % this.executionTime;
-      const deltaTime2 = time - this.lastTickDate;
-      this.lastTickDate = time;
-      this.dispatch(time, deltaTime2);
-    }
-  }
-  add({ callback, priority }) {
-    if (typeof callback !== "function")
-      console.error("Tempus.add: callback is not a function");
-    const uid = getUID();
-    this.callbacks.push({ callback, priority, uid });
-    this.callbacks.sort((a, b) => a.priority - b.priority);
-    return () => this.remove(uid);
-  }
-  remove(uid) {
-    this.callbacks = this.callbacks.filter(({ uid: u }) => uid !== u);
-  }
-};
-var TempusImpl = class {
-  framerates;
-  time;
-  constructor() {
-    this.framerates = {};
-    this.time = isClient ? performance.now() : 0;
-    if (!isClient) return;
-    requestAnimationFrame(this.raf);
-  }
-  add(callback, { priority = 0, fps = Number.POSITIVE_INFINITY } = {}) {
-    if (!isClient) return;
-    if (typeof fps === "number") {
-      if (!this.framerates[fps]) this.framerates[fps] = new Framerate(fps);
-      return this.framerates[fps].add({ callback, priority });
-    }
-  }
-  raf = (time) => {
-    if (!isClient) return;
-    requestAnimationFrame(this.raf, true);
-    const deltaTime = time - this.time;
-    this.time = time;
-    for (const framerate of Object.values(this.framerates)) {
-      framerate.raf(time, deltaTime);
-    }
-  };
-  patch() {
-    if (!isClient) return;
-    window.requestAnimationFrame = (callback, { priority = 0, fps = Number.POSITIVE_INFINITY } = {}) => {
-      if (callback === this.raf || !callback.toString().includes("requestAnimationFrame(")) {
-        return originalRAF(callback);
-      }
-      if (!callback.__tempusPatched) {
-        callback.__tempusPatched = true;
-        callback.__tempusUnsubscribe = this.add(callback, { priority, fps });
-      }
-      return callback.__tempusUnsubscribe;
-    };
-    window.cancelAnimationFrame = (callback) => {
-      if (typeof callback === "function") {
-        callback == null ? void 0 : callback();
-        return;
-      }
-      return originalCancelRAF(callback);
-    };
-  }
-  unpatch() {
-    if (!isClient) return;
-    window.requestAnimationFrame = originalRAF;
-    window.cancelAnimationFrame = originalCancelRAF;
-  }
-};
-var Tempus = new TempusImpl();
-
-// src/Tempus.ts
-var TempusUtilsManager = class {
-  cache = /* @__PURE__ */ new Map();
-  add(callback, options) {
-    const cancel = Tempus.add(callback, options);
-    this.cache.set(callback, cancel);
-  }
-  remove(callback) {
-    const cancel = this.cache.get(callback);
-    if (cancel) {
-      cancel();
-      this.cache.delete(callback);
-    }
-  }
-};
-var TempusUtils = new TempusUtilsManager();
-export {
-  CanvasUtils,
-  DOMUtils,
-  Detection,
-  DetectionManager,
-  MathUtils,
-  TempusUtils,
-  TempusUtilsManager
-};
+import './Polyfill.js';
+export * from './Canvas.js';
+export * from './Detection.js';
+export * from './DOM.js';
+export * from './Math.js';
+export * from './Tempus.js';

package/package.json

@@ -1,16 +1,17 @@
 {
   "name": "@lisergia/utilities",
-  "version": "23.0.0",
+  "version": "25.0.0",
+  "files": [
+    "dist"
+  ],
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "type": "module",
   "scripts": {
-    "build": "tsup src/index.ts --format cjs,esm --dts",
-    "dev": "tsup src/index.ts --format cjs,esm --dts --watch"
+    "build": "tsc --build --clean && tsc --build",
+    "dev": "tsc --build --watch"
   },
   "dependencies": {
-    "@lisergia/config-tsconfig": "23.0.0",
-    "gsap": "^3.13.0",
-    "tsup": "^8.5.0"
+    "@lisergia/config-tsconfig": "25.0.0"
   }
 }

package/.turbo/turbo-build.log

@@ -1,20 +0,0 @@
-
-
-> @lisergia/utilities@22.0.0 build
-> tsup src/index.ts --format cjs,esm --dts
-
-CLI Building entry: src/index.ts
-CLI Using tsconfig: tsconfig.json
-CLI tsup v8.5.0
-CLI Target: node16
-CJS Build start
-ESM Build start
-ESM dist/index.js 6.50 KB
-ESM ⚡️ Build success in 134ms
-CJS dist/index.cjs 7.71 KB
-CJS ⚡️ Build success in 135ms
-DTS Build start
-DTS ⚡️ Build success in 685ms
-DTS dist/index.d.cts 1.32 KB
-DTS dist/index.d.ts  1.32 KB
-⠙