@studiometa/js-toolkit 2.0.0 → 2.2.0-alpha.0

package/utils/isFunction.cjs

@@ -0,0 +1,28 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/js-toolkit/utils/isFunction.js
+var isFunction_exports = {};
+__export(isFunction_exports, {
+  default: () => isFunction
+});
+module.exports = __toCommonJS(isFunction_exports);
+function isFunction(fn) {
+  return typeof fn === "function";
+}
+if (module.exports.default) module.exports = module.exports.default;

package/utils/isFunction.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Test if the given value is a function.
+ *
+ * @param   {any} fn
+ * @returns {boolean}
+ */
+export default function isFunction(fn: any): boolean;

package/utils/isFunction.js

@@ -0,0 +1,6 @@
+function isFunction(fn) {
+  return typeof fn === "function";
+}
+export {
+  isFunction as default
+};

package/utils/math/index.cjs

@@ -26,6 +26,7 @@ __export(math_exports, {
   clamp: () => import_clamp.default,
   clamp01: () => import_clamp01.default,
   damp: () => import_damp.default,
+  ease: () => ease,
   inertiaFinalValue: () => import_inertiaFinalValue.default,
   lerp: () => import_lerp.default,
   map: () => import_map.default,
@@ -40,4 +41,5 @@ var import_lerp = __toESM(require("./lerp.cjs"), 1);
 var import_map = __toESM(require("./map.cjs"), 1);
 var import_round = __toESM(require("./round.cjs"), 1);
 __reExport(math_exports, require("./ease.cjs"), module.exports);
+var ease = __toESM(require("./ease.cjs"), 1);
 if (module.exports.default) module.exports = module.exports.default;

package/utils/math/index.d.ts

@@ -6,3 +6,4 @@ export { default as lerp } from "./lerp.js";
 export { default as map } from "./map.js";
 export { default as round } from "./round.js";
 export * from "./ease.js";
+export * as ease from "./ease.js";

package/utils/math/index.js

@@ -6,10 +6,12 @@ import { default as default6 } from "./lerp.js";
 import { default as default7 } from "./map.js";
 import { default as default8 } from "./round.js";
 export * from "./ease.js";
+import * as ease from "./ease.js";
 export {
   default2 as clamp,
   default3 as clamp01,
   default4 as damp,
+  ease,
   default5 as inertiaFinalValue,
   default6 as lerp,
   default7 as map,

package/utils/scheduler.cjs

@@ -0,0 +1,72 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/js-toolkit/utils/scheduler.js
+var scheduler_exports = {};
+__export(scheduler_exports, {
+  domScheduler: () => domScheduler,
+  useScheduler: () => useScheduler
+});
+module.exports = __toCommonJS(scheduler_exports);
+function getScheduler(steps) {
+  const stepsFns = {};
+  const api = {};
+  let isScheduled = false;
+  function run(tasks) {
+    let task;
+    while (task = tasks.shift()) {
+      task();
+    }
+  }
+  function flush() {
+    steps.forEach(function runStep(step) {
+      run(stepsFns[step]);
+    });
+    isScheduled = false;
+    if (steps.reduce((length, step) => length + stepsFns[step].length, 0) > 0) {
+      scheduleFlush();
+    }
+  }
+  function scheduleFlush() {
+    if (isScheduled) {
+      return;
+    }
+    isScheduled = true;
+    requestAnimationFrame(flush);
+  }
+  steps.forEach((step) => {
+    stepsFns[step] = [];
+    api[step] = function add(fn) {
+      stepsFns[step].push(fn);
+      scheduleFlush();
+    };
+  });
+  return api;
+}
+var instances = /* @__PURE__ */ new Map();
+function useScheduler(steps = ["read", "write"]) {
+  const key = steps.join("-");
+  if (instances.has(key)) {
+    return instances.get(key);
+  }
+  const scheduler = getScheduler(steps);
+  instances.set(key, scheduler);
+  return scheduler;
+}
+var domScheduler = useScheduler(["read", "write", "afterWrite"]);
+if (module.exports.default) module.exports = module.exports.default;

package/utils/scheduler.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Use a scheduler based on the given steps.
+ * @param   {string[]}  steps
+ * @returns {ReturnType<getScheduler>}
+ */
+export function useScheduler(steps?: string[]): ReturnType<typeof getScheduler>;
+export const domScheduler: Record<string, (fn: () => void) => void>;
+/**
+ * Generate a scheduler.
+ */
+export type T = string;
+/**
+ * Generate a scheduler.
+ * @typedef {string} T
+ * @param   {T[]} steps
+ * @returns {Record<T, (fn: () => void) => void>}
+ */
+declare function getScheduler(steps: T[]): Record<string, (fn: () => void) => void>;
+export {};

package/utils/scheduler.js

@@ -0,0 +1,50 @@
+function getScheduler(steps) {
+  const stepsFns = {};
+  const api = {};
+  let isScheduled = false;
+  function run(tasks) {
+    let task;
+    while (task = tasks.shift()) {
+      task();
+    }
+  }
+  function flush() {
+    steps.forEach(function runStep(step) {
+      run(stepsFns[step]);
+    });
+    isScheduled = false;
+    if (steps.reduce((length, step) => length + stepsFns[step].length, 0) > 0) {
+      scheduleFlush();
+    }
+  }
+  function scheduleFlush() {
+    if (isScheduled) {
+      return;
+    }
+    isScheduled = true;
+    requestAnimationFrame(flush);
+  }
+  steps.forEach((step) => {
+    stepsFns[step] = [];
+    api[step] = function add(fn) {
+      stepsFns[step].push(fn);
+      scheduleFlush();
+    };
+  });
+  return api;
+}
+const instances = /* @__PURE__ */ new Map();
+function useScheduler(steps = ["read", "write"]) {
+  const key = steps.join("-");
+  if (instances.has(key)) {
+    return instances.get(key);
+  }
+  const scheduler = getScheduler(steps);
+  instances.set(key, scheduler);
+  return scheduler;
+}
+const domScheduler = useScheduler(["read", "write", "afterWrite"]);
+export {
+  domScheduler,
+  useScheduler
+};