@studiometa/js-toolkit 2.2.3 → 2.3.0

package/utils/nextFrame.js

@@ -1,12 +1,14 @@
+import { isFunction } from "./is.js";
+import { hasWindow } from "./has.js";
 function getRaf() {
-  return typeof window !== "undefined" && window.requestAnimationFrame ? window.requestAnimationFrame.bind(window) : setTimeout;
+  return hasWindow() && window.requestAnimationFrame ? window.requestAnimationFrame.bind(window) : setTimeout;
 }
 function getCancelRaf() {
-  return typeof window !== "undefined" && window.cancelAnimationFrame ? window.cancelAnimationFrame.bind(window) : clearTimeout;
+  return hasWindow() && window.cancelAnimationFrame ? window.cancelAnimationFrame.bind(window) : clearTimeout;
 }
 function nextFrame(fn) {
   return new Promise((resolve) => {
-    getRaf()(() => resolve(typeof fn === "function" && fn()));
+    getRaf()(() => resolve(isFunction(fn) && fn()));
   });
 }
 export {

package/utils/nextMicrotask.cjs

@@ -22,7 +22,8 @@ __export(nextMicrotask_exports, {
   default: () => nextMicrotask
 });
 module.exports = __toCommonJS(nextMicrotask_exports);
+var import_is = require("./is.cjs");
 async function nextMicrotask(fn) {
-  return Promise.resolve().then(() => typeof fn === "function" && fn());
+  return Promise.resolve().then(() => (0, import_is.isFunction)(fn) && fn());
 }
 if (module.exports.default) module.exports = module.exports.default;

package/utils/nextMicrotask.js

@@ -1,5 +1,6 @@
+import { isFunction } from "./is.js";
 async function nextMicrotask(fn) {
-  return Promise.resolve().then(() => typeof fn === "function" && fn());
+  return Promise.resolve().then(() => isFunction(fn) && fn());
 }
 export {
   nextMicrotask as default

package/utils/nextTick.cjs

@@ -22,9 +22,10 @@ __export(nextTick_exports, {
   default: () => nextTick
 });
 module.exports = __toCommonJS(nextTick_exports);
+var import_is = require("./is.cjs");
 async function nextTick(fn) {
   return new Promise((resolve) => setTimeout(() => {
-    resolve(typeof fn === "function" && fn());
+    resolve((0, import_is.isFunction)(fn) && fn());
   }, 0));
 }
 if (module.exports.default) module.exports = module.exports.default;

package/utils/nextTick.js

@@ -1,6 +1,7 @@
+import { isFunction } from "./is.js";
 async function nextTick(fn) {
   return new Promise((resolve) => setTimeout(() => {
-    resolve(typeof fn === "function" && fn());
+    resolve(isFunction(fn) && fn());
   }, 0));
 }
 export {

package/utils/object/autoBind.cjs

@@ -26,10 +26,11 @@ __export(autoBind_exports, {
 });
 module.exports = __toCommonJS(autoBind_exports);
 var import_getAllProperties = __toESM(require("./getAllProperties.cjs"), 1);
+var import_is = require("../is.cjs");
 function autoBind(instance, options) {
   const { exclude, include } = options || {};
   const filter = (key) => {
-    const match = (pattern) => typeof pattern === "string" ? key === pattern : pattern.test(key);
+    const match = (pattern) => (0, import_is.isString)(pattern) ? key === pattern : pattern.test(key);
     if (include) {
       return include.some(match);
     }
@@ -40,7 +41,7 @@ function autoBind(instance, options) {
   };
   (0, import_getAllProperties.default)(instance).filter(([key]) => key !== "constructor" && filter(key)).forEach(([key, object]) => {
     const descriptor = Object.getOwnPropertyDescriptor(object, key);
-    if (descriptor && typeof descriptor.value === "function") {
+    if (descriptor && (0, import_is.isFunction)(descriptor.value)) {
       instance[key] = instance[key].bind(instance);
     }
   });

package/utils/object/autoBind.js

@@ -1,8 +1,9 @@
 import getAllProperties from "./getAllProperties.js";
+import { isString, isFunction } from "../is.js";
 function autoBind(instance, options) {
   const { exclude, include } = options || {};
   const filter = (key) => {
-    const match = (pattern) => typeof pattern === "string" ? key === pattern : pattern.test(key);
+    const match = (pattern) => isString(pattern) ? key === pattern : pattern.test(key);
     if (include) {
       return include.some(match);
     }
@@ -13,7 +14,7 @@ function autoBind(instance, options) {
   };
   getAllProperties(instance).filter(([key]) => key !== "constructor" && filter(key)).forEach(([key, object]) => {
     const descriptor = Object.getOwnPropertyDescriptor(object, key);
-    if (descriptor && typeof descriptor.value === "function") {
+    if (descriptor && isFunction(descriptor.value)) {
       instance[key] = instance[key].bind(instance);
     }
   });

package/utils/object/getAllProperties.cjs

@@ -22,13 +22,14 @@ __export(getAllProperties_exports, {
   default: () => getAllProperties
 });
 module.exports = __toCommonJS(getAllProperties_exports);
+var import_is = require("../is.cjs");
 function getAllProperties(object, props = [], testFn = null) {
   const proto = Object.getPrototypeOf(object);
   if (proto === Object.prototype || proto === null) {
     return props;
   }
   let foundProps = Object.getOwnPropertyNames(proto);
-  if (typeof testFn === "function") {
+  if ((0, import_is.isFunction)(testFn)) {
     foundProps = foundProps.filter((name) => testFn(name, proto));
   }
   foundProps = foundProps.map((name) => [name, proto]).reduce((acc, val) => [...acc, val], props);

package/utils/object/getAllProperties.js

@@ -1,10 +1,11 @@
+import { isFunction } from "../is.js";
 function getAllProperties(object, props = [], testFn = null) {
   const proto = Object.getPrototypeOf(object);
   if (proto === Object.prototype || proto === null) {
     return props;
   }
   let foundProps = Object.getOwnPropertyNames(proto);
-  if (typeof testFn === "function") {
+  if (isFunction(testFn)) {
     foundProps = foundProps.filter((name) => testFn(name, proto));
   }
   foundProps = foundProps.map((name) => [name, proto]).reduce((acc, val) => [...acc, val], props);

package/utils/object/index.cjs

@@ -23,11 +23,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var object_exports = {};
 __export(object_exports, {
   autoBind: () => import_autoBind.default,
-  getAllProperties: () => import_getAllProperties.default,
-  isObject: () => import_isObject.default
+  getAllProperties: () => import_getAllProperties.default
 });
 module.exports = __toCommonJS(object_exports);
 var import_autoBind = __toESM(require("./autoBind.cjs"), 1);
 var import_getAllProperties = __toESM(require("./getAllProperties.cjs"), 1);
-var import_isObject = __toESM(require("./isObject.cjs"), 1);
 if (module.exports.default) module.exports = module.exports.default;

package/utils/object/index.d.ts

@@ -1,3 +1,2 @@
 export { default as autoBind } from "./autoBind.js";
 export { default as getAllProperties } from "./getAllProperties.js";
-export { default as isObject } from "./isObject.js";

package/utils/object/index.js

@@ -1,8 +1,6 @@
 import { default as default2 } from "./autoBind.js";
 import { default as default3 } from "./getAllProperties.js";
-import { default as default4 } from "./isObject.js";
 export {
   default2 as autoBind,
-  default3 as getAllProperties,
-  default4 as isObject
+  default3 as getAllProperties
 };

package/utils/tween.cjs

@@ -0,0 +1,113 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/js-toolkit/utils/tween.js
+var tween_exports = {};
+__export(tween_exports, {
+  normalizeEase: () => normalizeEase,
+  tween: () => tween
+});
+module.exports = __toCommonJS(tween_exports);
+var import_easing = require("@motionone/easing");
+var import_math = require("./math/index.cjs");
+var import_is = require("./is.cjs");
+var import_noop = require("./noop.cjs");
+var import_raf = __toESM(require("../services/raf.cjs"), 1);
+var id = 0;
+var PROGRESS_PRECISION = 1e-4;
+function normalizeEase(ease) {
+  if (!(0, import_is.isDefined)(ease)) {
+    return import_noop.noopValue;
+  }
+  if ((0, import_is.isArray)(ease)) {
+    return (0, import_easing.cubicBezier)(...ease);
+  }
+  return ease;
+}
+function tween(callback, options = {}) {
+  const raf = (0, import_raf.default)();
+  let progressValue = 0;
+  let easedProgress = 0;
+  const ease = normalizeEase(options.easing);
+  let duration = options.duration ?? 1;
+  duration *= 1e3;
+  let startTime = performance.now();
+  let endTime = startTime + duration;
+  const key = `tw-${id}`;
+  id += 1;
+  const { onStart = import_noop.noop, onProgress = import_noop.noop, onFinish = import_noop.noop } = options;
+  let isRunning = false;
+  function pause() {
+    isRunning = false;
+    raf.remove(key);
+  }
+  function progress(newProgress) {
+    if (typeof newProgress === "undefined") {
+      return easedProgress;
+    }
+    progressValue = newProgress;
+    easedProgress = ease(progressValue);
+    if (Math.abs(1 - easedProgress) < PROGRESS_PRECISION) {
+      progressValue = 1;
+      easedProgress = 1;
+    }
+    callback(easedProgress);
+    onProgress(progressValue, easedProgress);
+    if (easedProgress === 1) {
+      pause();
+      requestAnimationFrame(() => onFinish(progressValue, easedProgress));
+    }
+    return progressValue;
+  }
+  function tick(props) {
+    if (!isRunning) {
+      raf.remove(key);
+      return;
+    }
+    progress((0, import_math.clamp01)((0, import_math.map)(props.time, startTime, endTime, 0, 1)));
+  }
+  function start() {
+    onStart();
+    startTime = performance.now();
+    endTime = startTime + duration;
+    progressValue = 0;
+    easedProgress = 0;
+    isRunning = true;
+    raf.add(key, tick);
+  }
+  function play() {
+    if (isRunning) {
+      return;
+    }
+    startTime = performance.now() - (0, import_math.lerp)(0, duration, progressValue);
+    endTime = startTime + duration;
+    isRunning = true;
+    raf.add(key, tick);
+  }
+  return {
+    start,
+    finish: () => progress(1),
+    pause,
+    play,
+    progress
+  };
+}
+if (module.exports.default) module.exports = module.exports.default;

package/utils/tween.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @typedef {[number, number, number, number]} BezierCurve
+ * @typedef {{
+ *   duration?: number;
+ *   easing?: import('./math/createEases.js').EasingFunction|BezierCurve;
+ *   onStart?: () => void;
+ *   onProgress?: (progress: number, easedProgress: number) => void;
+ *   onFinish?: (progress: number, easedProgress: number) => void;
+ *  }} TweenOptions
+ */
+/**
+ * Normalize a easing function with default fallbacks.
+ * @param   {((p:number) => number)|[number,number,number,number]} ease
+ * @returns {(p:number) => number}
+ */
+export function normalizeEase(ease: [number, number, number, number] | ((p: number) => number)): (p: number) => number;
+/**
+ * Tween from 0 to 1.
+ * @param   {(progress:number)=>any} callback
+ * @param   {TweenOptions} [options]
+ * @returns {any}
+ */
+export function tween(callback: (progress: number) => any, options?: TweenOptions): any;
+export type BezierCurve = [number, number, number, number];
+export type TweenOptions = TweenOptions;

package/utils/tween.js

@@ -0,0 +1,88 @@
+import { cubicBezier } from "@motionone/easing";
+import { lerp, map, clamp01 } from "./math/index.js";
+import { isDefined, isArray } from "./is.js";
+import { noop, noopValue as linear } from "./noop.js";
+import useRaf from "../services/raf.js";
+let id = 0;
+const PROGRESS_PRECISION = 1e-4;
+function normalizeEase(ease) {
+  if (!isDefined(ease)) {
+    return linear;
+  }
+  if (isArray(ease)) {
+    return cubicBezier(...ease);
+  }
+  return ease;
+}
+function tween(callback, options = {}) {
+  const raf = useRaf();
+  let progressValue = 0;
+  let easedProgress = 0;
+  const ease = normalizeEase(options.easing);
+  let duration = options.duration ?? 1;
+  duration *= 1e3;
+  let startTime = performance.now();
+  let endTime = startTime + duration;
+  const key = `tw-${id}`;
+  id += 1;
+  const { onStart = noop, onProgress = noop, onFinish = noop } = options;
+  let isRunning = false;
+  function pause() {
+    isRunning = false;
+    raf.remove(key);
+  }
+  function progress(newProgress) {
+    if (typeof newProgress === "undefined") {
+      return easedProgress;
+    }
+    progressValue = newProgress;
+    easedProgress = ease(progressValue);
+    if (Math.abs(1 - easedProgress) < PROGRESS_PRECISION) {
+      progressValue = 1;
+      easedProgress = 1;
+    }
+    callback(easedProgress);
+    onProgress(progressValue, easedProgress);
+    if (easedProgress === 1) {
+      pause();
+      requestAnimationFrame(() => onFinish(progressValue, easedProgress));
+    }
+    return progressValue;
+  }
+  function tick(props) {
+    if (!isRunning) {
+      raf.remove(key);
+      return;
+    }
+    progress(clamp01(map(props.time, startTime, endTime, 0, 1)));
+  }
+  function start() {
+    onStart();
+    startTime = performance.now();
+    endTime = startTime + duration;
+    progressValue = 0;
+    easedProgress = 0;
+    isRunning = true;
+    raf.add(key, tick);
+  }
+  function play() {
+    if (isRunning) {
+      return;
+    }
+    startTime = performance.now() - lerp(0, duration, progressValue);
+    endTime = startTime + duration;
+    isRunning = true;
+    raf.add(key, tick);
+  }
+  return {
+    start,
+    finish: () => progress(1),
+    pause,
+    play,
+    progress
+  };
+}
+export {
+  normalizeEase,
+  tween
+};

package/utils/isDefined.d.ts

@@ -1,7 +0,0 @@
-/**
- * Test if a value is defined or not.
- *
- * @param   {any} value
- * @returns {boolean}
- */
-export default function isDefined(value: any): boolean;

package/utils/isDefined.js

@@ -1,6 +0,0 @@
-function isDefined(value) {
-  return typeof value !== "undefined";
-}
-export {
-  isDefined as default
-};

package/utils/isFunction.d.ts

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

package/utils/isFunction.js

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

package/utils/object/isObject.cjs

@@ -1,28 +0,0 @@
-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/object/isObject.js
-var isObject_exports = {};
-__export(isObject_exports, {
-  default: () => isObject
-});
-module.exports = __toCommonJS(isObject_exports);
-function isObject(value) {
-  return typeof value === "object" && !!value && value.toString() === "[object Object]";
-}
-if (module.exports.default) module.exports = module.exports.default;

package/utils/object/isObject.d.ts

@@ -1,7 +0,0 @@
-/**
- * Test if the given value is an object.
- *
- * @param {*} value The value to test.
- * @returns {boolean} Whether or not the value is an object.
- */
-export default function isObject(value: any): boolean;

package/utils/object/isObject.js

@@ -1,6 +0,0 @@
-function isObject(value) {
-  return typeof value === "object" && !!value && value.toString() === "[object Object]";
-}
-export {
-  isObject as default
-};