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

package/utils/css/animate.js

@@ -0,0 +1,182 @@
+import { cubicBezier } from "@motionone/easing";
+import { lerp, map, clamp01 } from "../math/index.js";
+import isDefined from "../isDefined.js";
+import transform, { TRANSFORM_PROPS } from "./transform.js";
+import useRaf from "../../services/raf.js";
+import { domScheduler as scheduler } from "../scheduler.js";
+let id = 0;
+const running = /* @__PURE__ */ new WeakMap();
+const raf = useRaf();
+const noop = () => {
+};
+const PROGRESS_PRECISION = 1e-4;
+const CSSUnitConverter = {
+  "%": (value, getSizeRef) => value * getSizeRef() / 100,
+  vh: (value) => value * window.innerHeight / 100,
+  vw: (value) => value * window.innerWidth / 100,
+  vmin: (value) => value * Math.min(window.innerWidth, window.innerHeight) / 100,
+  vmax: (value) => value * Math.max(window.innerWidth, window.innerHeight) / 100
+};
+function getAnimationStepValue(val, getSizeRef) {
+  if (typeof val === "number") {
+    return val;
+  }
+  if (!val[1] || !CSSUnitConverter[val[1]]) {
+    return val[0];
+  }
+  return CSSUnitConverter[val[1]](val[0], getSizeRef);
+}
+function linear(value) {
+  return value;
+}
+function normalizeEase(ease) {
+  if (!isDefined(ease)) {
+    return linear;
+  }
+  if (Array.isArray(ease)) {
+    return cubicBezier(...ease);
+  }
+  return ease;
+}
+const generateTranslateRenderStrategy = (sizeRef) => (element, fromValue, toValue, progress) => lerp(getAnimationStepValue(fromValue != null ? fromValue : 0, () => element[sizeRef]), getAnimationStepValue(toValue != null ? toValue : 0, () => element[sizeRef]), progress);
+const widthBasedTranslateRenderStrategy = generateTranslateRenderStrategy("offsetWidth");
+const heightBasedTranslateRenderStrategy = generateTranslateRenderStrategy("offsetHeight");
+const generateLerpRenderStrategy = (defaultValue) => (element, fromValue, toValue, progress) => lerp(fromValue != null ? fromValue : defaultValue, toValue != null ? toValue : defaultValue, progress);
+const scaleRenderStrategy = generateLerpRenderStrategy(1);
+const degreesRenderStrategy = generateLerpRenderStrategy(0);
+const transformRenderStrategies = {
+  x: widthBasedTranslateRenderStrategy,
+  y: heightBasedTranslateRenderStrategy,
+  z: widthBasedTranslateRenderStrategy,
+  scale: scaleRenderStrategy,
+  scaleX: scaleRenderStrategy,
+  scaleY: scaleRenderStrategy,
+  scaleZ: scaleRenderStrategy,
+  skew: degreesRenderStrategy,
+  skewX: degreesRenderStrategy,
+  skewY: degreesRenderStrategy,
+  rotate: degreesRenderStrategy,
+  rotateX: degreesRenderStrategy,
+  rotateY: degreesRenderStrategy,
+  rotateZ: degreesRenderStrategy
+};
+function render(element, from, to, progress) {
+  const stepProgress = to.easing(map(progress, from.offset, to.offset, 0, 1));
+  scheduler.read(function renderRead() {
+    var _a, _b;
+    let opacity = false;
+    if (isDefined(from.opacity) || isDefined(to.opacity)) {
+      opacity = map(stepProgress, 0, 1, (_a = from.opacity) != null ? _a : 1, (_b = to.opacity) != null ? _b : 1);
+    } else if (element.style.opacity) {
+      opacity = "";
+    }
+    let transformOrigin = false;
+    if (isDefined(to.transformOrigin)) {
+      transformOrigin = to.transformOrigin;
+    } else if (element.style.transformOrigin) {
+      transformOrigin = "";
+    }
+    const props = Object.fromEntries(TRANSFORM_PROPS.filter((name) => isDefined(from[name]) || isDefined(to[name])).map((name) => {
+      return [name, transformRenderStrategies[name](element, from[name], to[name], stepProgress)];
+    }));
+    scheduler.write(function renderWrite() {
+      if (opacity !== false) {
+        element.style.opacity = opacity;
+      }
+      if (transformOrigin !== false) {
+        element.style.transformOrigin = transformOrigin;
+      }
+      transform(element, props);
+    });
+  });
+}
+function animate(element, keyframes, options = {}) {
+  var _a;
+  let progressValue = 0;
+  let easedProgress = 0;
+  if (!running.has(element)) {
+    running.set(element, /* @__PURE__ */ new Map());
+  }
+  const ease = normalizeEase(options.easing);
+  let duration = (_a = options.duration) != null ? _a : 1;
+  duration *= 1e3;
+  let startTime = performance.now();
+  let endTime = startTime + duration;
+  const key = `animate-${id}`;
+  id += 1;
+  const { onProgress = noop, onFinish = noop } = options;
+  let isRunning = false;
+  const keyframesCount = keyframes.length - 1;
+  const normalizedKeyframes = keyframes.map((keyframe, index) => {
+    var _a2;
+    return {
+      ...keyframe,
+      offset: (_a2 = keyframe.offset) != null ? _a2 : index / keyframesCount,
+      easing: normalizeEase(keyframe.easing)
+    };
+  });
+  function pause() {
+    isRunning = false;
+    raf.remove(key);
+  }
+  function progress(newProgress) {
+    if (typeof newProgress === "undefined") {
+      return progressValue;
+    }
+    progressValue = newProgress;
+    if (Math.abs(1 - progressValue) < PROGRESS_PRECISION) {
+      progressValue = 1;
+      pause();
+      scheduler.afterWrite(() => onFinish(progressValue, easedProgress));
+    }
+    easedProgress = ease(progressValue);
+    let toIndex = 0;
+    while (normalizedKeyframes[toIndex] && normalizedKeyframes[toIndex].offset <= easedProgress && normalizedKeyframes[toIndex].offset !== 1) {
+      toIndex += 1;
+    }
+    render(element, normalizedKeyframes[toIndex - 1], normalizedKeyframes[toIndex], easedProgress);
+    onProgress(progressValue, easedProgress);
+    return progressValue;
+  }
+  function tick(props) {
+    if (!isRunning) {
+      raf.remove(key);
+      return;
+    }
+    progress(clamp01(map(props.time, startTime, endTime, 0, 1)));
+  }
+  function start() {
+    const runningKeys = running.get(element);
+    runningKeys.forEach((runningPause, runningKey) => {
+      runningPause();
+      runningKeys.delete(runningKey);
+    });
+    runningKeys.set(key, pause);
+    running.set(element, runningKeys);
+    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 {
+  animate
+};

package/utils/css/getOffsetSizes.cjs

@@ -0,0 +1,47 @@
+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/css/getOffsetSizes.js
+var getOffsetSizes_exports = {};
+__export(getOffsetSizes_exports, {
+  default: () => getOffsetSizes
+});
+module.exports = __toCommonJS(getOffsetSizes_exports);
+function getOffsetSizes(element) {
+  let parent = element;
+  let x = -window.pageXOffset;
+  let y = -window.pageYOffset;
+  while (parent) {
+    x += parent.offsetLeft;
+    y += parent.offsetTop;
+    parent = parent.offsetParent;
+  }
+  const width = element.offsetWidth;
+  const height = element.offsetWidth;
+  return {
+    x,
+    y,
+    width,
+    height,
+    top: y,
+    right: width + x,
+    bottom: height + y,
+    left: x
+  };
+}
+if (module.exports.default) module.exports = module.exports.default;

package/utils/css/getOffsetSizes.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Get a `DOMRect` like `Object` for an element, without its transforms.
+ * @param   {HTMLElement} element
+ * @returns {{ x: number, y: number, width: number, height: number, top: number, right: number, bottom: number, left: number }}
+ */
+export default function getOffsetSizes(element: HTMLElement): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+};

package/utils/css/getOffsetSizes.js

@@ -0,0 +1,25 @@
+function getOffsetSizes(element) {
+  let parent = element;
+  let x = -window.pageXOffset;
+  let y = -window.pageYOffset;
+  while (parent) {
+    x += parent.offsetLeft;
+    y += parent.offsetTop;
+    parent = parent.offsetParent;
+  }
+  const width = element.offsetWidth;
+  const height = element.offsetWidth;
+  return {
+    x,
+    y,
+    width,
+    height,
+    top: y,
+    right: width + x,
+    bottom: height + y,
+    left: x
+  };
+}
+export {
+  getOffsetSizes as default
+};

package/utils/css/index.cjs

@@ -16,6 +16,7 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 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);
 
@@ -24,15 +25,20 @@ var css_exports = {};
 __export(css_exports, {
   addClass: () => import_classes.add,
   addStyle: () => import_styles.add,
+  getOffsetSizes: () => import_getOffsetSizes.default,
   matrix: () => import_matrix.default,
   removeClass: () => import_classes.remove,
   removeStyle: () => import_styles.remove,
   toggleClass: () => import_classes.toggle,
+  transform: () => import_transform.default,
   transition: () => import_transition.default
 });
 module.exports = __toCommonJS(css_exports);
+__reExport(css_exports, require("./animate.cjs"), module.exports);
 var import_classes = require("./classes.cjs");
 var import_styles = require("./styles.cjs");
+var import_getOffsetSizes = __toESM(require("./getOffsetSizes.cjs"), 1);
 var import_matrix = __toESM(require("./matrix.cjs"), 1);
+var import_transform = __toESM(require("./transform.cjs"), 1);
 var import_transition = __toESM(require("./transition.cjs"), 1);
 if (module.exports.default) module.exports = module.exports.default;

package/utils/css/index.d.ts

@@ -1,4 +1,7 @@
+export * from "./animate.js";
+export { default as getOffsetSizes } from "./getOffsetSizes.js";
 export { default as matrix } from "./matrix.js";
+export { default as transform } from "./transform.js";
 export { default as transition } from "./transition.js";
 export { add as addClass, remove as removeClass, toggle as toggleClass } from "./classes.js";
 export { add as addStyle, remove as removeStyle } from "./styles.js";

package/utils/css/index.js

@@ -1,13 +1,18 @@
+export * from "./animate.js";
 import { add, remove, toggle } from "./classes.js";
 import { add as add2, remove as remove2 } from "./styles.js";
-import { default as default2 } from "./matrix.js";
-import { default as default3 } from "./transition.js";
+import { default as default2 } from "./getOffsetSizes.js";
+import { default as default3 } from "./matrix.js";
+import { default as default4 } from "./transform.js";
+import { default as default5 } from "./transition.js";
 export {
   add as addClass,
   add2 as addStyle,
-  default2 as matrix,
+  default2 as getOffsetSizes,
+  default3 as matrix,
   remove as removeClass,
   remove2 as removeStyle,
   toggle as toggleClass,
-  default3 as transition
+  default4 as transform,
+  default5 as transition
 };

package/utils/css/transform.cjs

@@ -0,0 +1,91 @@
+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/css/transform.js
+var transform_exports = {};
+__export(transform_exports, {
+  TRANSFORM_PROPS: () => TRANSFORM_PROPS,
+  default: () => transform
+});
+module.exports = __toCommonJS(transform_exports);
+var import_isDefined = __toESM(require("../isDefined.cjs"), 1);
+var TRANSFORM_PROPS = [
+  "x",
+  "y",
+  "z",
+  "rotate",
+  "rotateX",
+  "rotateY",
+  "rotateZ",
+  "scale",
+  "scaleX",
+  "scaleY",
+  "scaleZ",
+  "skew",
+  "skewX",
+  "skewY"
+];
+function transform(element, props) {
+  var _a, _b, _c;
+  let value = "";
+  if ((0, import_isDefined.default)(props.x) || (0, import_isDefined.default)(props.y) || (0, import_isDefined.default)(props.z)) {
+    value += `translate3d(${(_a = props.x) != null ? _a : 0}px, ${(_b = props.y) != null ? _b : 0}px, ${(_c = props.z) != null ? _c : 0}px) `;
+  }
+  if ((0, import_isDefined.default)(props.rotate)) {
+    value += `rotate(${props.rotate}deg) `;
+  } else {
+    if ((0, import_isDefined.default)(props.rotateX)) {
+      value += `rotateX(${props.rotateX}deg) `;
+    }
+    if ((0, import_isDefined.default)(props.rotateY)) {
+      value += `rotateY(${props.rotateY}deg) `;
+    }
+    if ((0, import_isDefined.default)(props.rotateZ)) {
+      value += `rotateZ(${props.rotateZ}deg) `;
+    }
+  }
+  if ((0, import_isDefined.default)(props.scale)) {
+    value += `scale(${props.scale}) `;
+  } else {
+    if ((0, import_isDefined.default)(props.scaleX)) {
+      value += `scaleX(${props.scaleX}) `;
+    }
+    if ((0, import_isDefined.default)(props.scaleY)) {
+      value += `scaleY(${props.scaleY}) `;
+    }
+    if ((0, import_isDefined.default)(props.scaleZ)) {
+      value += `scaleZ(${props.scaleZ}) `;
+    }
+  }
+  if ((0, import_isDefined.default)(props.skew)) {
+    value += `skew(${props.skew}deg) `;
+  } else {
+    if ((0, import_isDefined.default)(props.skewX)) {
+      value += `skewX(${props.skewX}deg) `;
+    }
+    if ((0, import_isDefined.default)(props.skewY)) {
+      value += `skewY(${props.skewY}deg) `;
+    }
+  }
+  element.style.transform = value;
+  return value;
+}
+if (module.exports.default) module.exports = module.exports.default;

package/utils/css/transform.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Generate a CSS transform.
+ *
+ * @param   {HTMLElement} element
+ * @param   {TransformProps} props
+ * @returns {string}
+ */
+export default function transform(element: HTMLElement, props: TransformProps): string;
+/**
+ * @typedef {Partial<{
+ *  x: number;
+ *  y: number;
+ *  z: number;
+ *  rotate: number;
+ *  rotateX: number;
+ *  rotateY: number;
+ *  rotateZ: number;
+ *  scale: number;
+ *  scaleX: number;
+ *  scaleY: number;
+ *  scaleZ: number;
+ *  skew: number;
+ *  skewX: number;
+ *  skewY: number;
+ * }>} TransformProps
+ */
+export const TRANSFORM_PROPS: string[];
+export type TransformProps = Partial<{
+    x: number;
+    y: number;
+    z: number;
+    rotate: number;
+    rotateX: number;
+    rotateY: number;
+    rotateZ: number;
+    scale: number;
+    scaleX: number;
+    scaleY: number;
+    scaleZ: number;
+    skew: number;
+    skewX: number;
+    skewY: number;
+}>;

package/utils/css/transform.js

@@ -0,0 +1,66 @@
+import isDefined from "../isDefined.js";
+const TRANSFORM_PROPS = [
+  "x",
+  "y",
+  "z",
+  "rotate",
+  "rotateX",
+  "rotateY",
+  "rotateZ",
+  "scale",
+  "scaleX",
+  "scaleY",
+  "scaleZ",
+  "skew",
+  "skewX",
+  "skewY"
+];
+function transform(element, props) {
+  var _a, _b, _c;
+  let value = "";
+  if (isDefined(props.x) || isDefined(props.y) || isDefined(props.z)) {
+    value += `translate3d(${(_a = props.x) != null ? _a : 0}px, ${(_b = props.y) != null ? _b : 0}px, ${(_c = props.z) != null ? _c : 0}px) `;
+  }
+  if (isDefined(props.rotate)) {
+    value += `rotate(${props.rotate}deg) `;
+  } else {
+    if (isDefined(props.rotateX)) {
+      value += `rotateX(${props.rotateX}deg) `;
+    }
+    if (isDefined(props.rotateY)) {
+      value += `rotateY(${props.rotateY}deg) `;
+    }
+    if (isDefined(props.rotateZ)) {
+      value += `rotateZ(${props.rotateZ}deg) `;
+    }
+  }
+  if (isDefined(props.scale)) {
+    value += `scale(${props.scale}) `;
+  } else {
+    if (isDefined(props.scaleX)) {
+      value += `scaleX(${props.scaleX}) `;
+    }
+    if (isDefined(props.scaleY)) {
+      value += `scaleY(${props.scaleY}) `;
+    }
+    if (isDefined(props.scaleZ)) {
+      value += `scaleZ(${props.scaleZ}) `;
+    }
+  }
+  if (isDefined(props.skew)) {
+    value += `skew(${props.skew}deg) `;
+  } else {
+    if (isDefined(props.skewX)) {
+      value += `skewX(${props.skewX}deg) `;
+    }
+    if (isDefined(props.skewY)) {
+      value += `skewY(${props.skewY}deg) `;
+    }
+  }
+  element.style.transform = value;
+  return value;
+}
+export {
+  TRANSFORM_PROPS,
+  transform as default
+};

package/utils/css/transition.cjs

@@ -68,8 +68,10 @@ async function start(element, classesOrStyles) {
   trs.isTransitioning = true;
   setClassesOrStyles(element, classesOrStyles.from);
   await (0, import_nextFrame.default)();
+  await (0, import_nextFrame.default)();
   setClassesOrStyles(element, classesOrStyles.active);
   await (0, import_nextFrame.default)();
+  await (0, import_nextFrame.default)();
 }
 async function next(element, classesOrStyles) {
   const hasTransition = testTransition(element);

package/utils/css/transition.js

@@ -41,8 +41,10 @@ async function start(element, classesOrStyles) {
   trs.isTransitioning = true;
   setClassesOrStyles(element, classesOrStyles.from);
   await nextFrame();
+  await nextFrame();
   setClassesOrStyles(element, classesOrStyles.active);
   await nextFrame();
+  await nextFrame();
 }
 async function next(element, classesOrStyles) {
   const hasTransition = testTransition(element);

package/utils/index.cjs

@@ -27,6 +27,8 @@ __export(utils_exports, {
   focusTrap: () => import_focusTrap.default,
   historyPush: () => import_history.push,
   historyReplace: () => import_history.replace,
+  isDefined: () => import_isDefined.default,
+  isFunction: () => import_isFunction.default,
   keyCodes: () => import_keyCodes.default,
   memoize: () => import_memoize.default,
   nextFrame: () => import_nextFrame.default,
@@ -46,9 +48,12 @@ var import_nextTick = __toESM(require("./nextTick.cjs"), 1);
 var import_nextMicrotask = __toESM(require("./nextMicrotask.cjs"), 1);
 var import_throttle = __toESM(require("./throttle.cjs"), 1);
 var import_scrollTo = __toESM(require("./scrollTo.cjs"), 1);
+var import_isDefined = __toESM(require("./isDefined.cjs"), 1);
+var import_isFunction = __toESM(require("./isFunction.cjs"), 1);
 __reExport(utils_exports, require("./css/index.cjs"), module.exports);
 var import_history = require("./history.cjs");
 __reExport(utils_exports, require("./collide/index.cjs"), module.exports);
 __reExport(utils_exports, require("./math/index.cjs"), module.exports);
 __reExport(utils_exports, require("./string/index.cjs"), module.exports);
+__reExport(utils_exports, require("./scheduler.cjs"), module.exports);
 if (module.exports.default) module.exports = module.exports.default;

package/utils/index.d.ts

@@ -7,8 +7,11 @@ export { default as nextTick } from "./nextTick.js";
 export { default as nextMicrotask } from "./nextMicrotask.js";
 export { default as throttle } from "./throttle.js";
 export { default as scrollTo } from "./scrollTo.js";
+export { default as isDefined } from "./isDefined.js";
+export { default as isFunction } from "./isFunction.js";
 export * from "./css/index.js";
 export * from "./collide/index.js";
 export * from "./math/index.js";
 export * from "./string/index.js";
+export * from "./scheduler.js";
 export { objectToURLSearchParams, push as historyPush, replace as historyReplace } from "./history.js";

package/utils/index.js

@@ -7,6 +7,8 @@ import { default as default7 } from "./nextTick.js";
 import { default as default8 } from "./nextMicrotask.js";
 import { default as default9 } from "./throttle.js";
 import { default as default10 } from "./scrollTo.js";
+import { default as default11 } from "./isDefined.js";
+import { default as default12 } from "./isFunction.js";
 export * from "./css/index.js";
 import {
   objectToURLSearchParams,
@@ -16,11 +18,14 @@ import {
 export * from "./collide/index.js";
 export * from "./math/index.js";
 export * from "./string/index.js";
+export * from "./scheduler.js";
 export {
   default2 as debounce,
   default3 as focusTrap,
   push as historyPush,
   replace as historyReplace,
+  default11 as isDefined,
+  default12 as isFunction,
   default4 as keyCodes,
   default5 as memoize,
   default6 as nextFrame,

package/utils/isDefined.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/isDefined.js
+var isDefined_exports = {};
+__export(isDefined_exports, {
+  default: () => isDefined
+});
+module.exports = __toCommonJS(isDefined_exports);
+function isDefined(value) {
+  return typeof value !== "undefined";
+}
+if (module.exports.default) module.exports = module.exports.default;

package/utils/isDefined.d.ts

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

package/utils/isDefined.js

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