@studiometa/ui 0.2.4 → 0.2.7

package/atoms/ScrollAnimation/AbstractScrollAnimation.d.ts

@@ -0,0 +1,133 @@
+/**
+ * @typedef {AbstractScrollAnimation & {
+ *   $options: {
+ *     playRange: string,
+ *     dampFactor: number,
+ *     dampPrecision: number,
+ *     from: AnimationOptions,
+ *     to: AnimationOptions,
+ *   },
+ * }} ScrollAnimationChildInterface
+ */
+/**
+ * AbstractScrollAnimation class.
+ *
+ * @todo add support for magic values in options to access key values:
+ * - viewport size
+ * - target size
+ * - root element size
+ * - etc.
+ *
+ * ```
+ * data-option-to="{ x: 100%, y: innerWidth / 2 }"
+ * ```
+ */
+export default class AbstractScrollAnimation extends Base {
+    /**
+     * Config.
+     */
+    static config: {
+        name: string;
+        options: {
+            playRange: {
+                type: ArrayConstructor;
+                default: () => number[];
+            };
+            dampFactor: {
+                type: NumberConstructor;
+                default: number;
+            };
+            dampPrecision: {
+                type: NumberConstructor;
+                default: number;
+            };
+            from: {
+                type: ObjectConstructor;
+                default: typeof getDefaults;
+                merge: boolean;
+            };
+            to: {
+                type: ObjectConstructor;
+                default: typeof getDefaults;
+                merge: boolean;
+            };
+        };
+    };
+    /**
+     * Get the target element for the animation.
+     *
+     * @returns {HTMLElement}
+     */
+    get target(): HTMLElement;
+    /**
+     * Flags for style detection.
+     */
+    get has(): {
+        x: boolean;
+        y: boolean;
+        z: boolean;
+        scale: boolean;
+        scaleX: boolean;
+        scaleY: boolean;
+        rotate: boolean;
+        skewX: boolean;
+        skewY: boolean;
+        opacity: boolean;
+        transform: boolean;
+    };
+    /**
+     * @todo do not add unnecessary styles
+     */
+    scrolledInView(props: any): void;
+    /**
+     * Render the animation for the given progress.
+     *
+     * @param   {number} progress
+     * @returns {void}
+     */
+    render(progress: number): void;
+}
+export type AbstractScrollAnimationConstructor = typeof AbstractScrollAnimation;
+export type AnimationOptions = {
+    x?: number;
+    y?: number;
+    z?: number;
+    scale?: number;
+    scaleX?: number;
+    scaleY?: number;
+    rotate?: number;
+    skewX?: number;
+    skewY?: number;
+    opacity?: number;
+};
+export type ScrollAnimationChildInterface = AbstractScrollAnimation & {
+    $options: {
+        playRange: string;
+        dampFactor: number;
+        dampPrecision: number;
+        from: AnimationOptions;
+        to: AnimationOptions;
+    };
+};
+import { Base } from "@studiometa/js-toolkit";
+/**
+ * @typedef {typeof AbstractScrollAnimation} AbstractScrollAnimationConstructor
+ * @typedef {{
+ *   x?: number;
+ *   y?: number;
+ *   z?: number;
+ *   scale?: number;
+ *   scaleX?: number;
+ *   scaleY?: number;
+ *   rotate?: number;
+ *   skewX?: number;
+ *   skewY?: number;
+ *   opacity?: number;
+ * }} AnimationOptions
+ */
+/**
+ * Get animation configuration defaults.
+ * @returns {AnimationOptions}
+ */
+declare function getDefaults(): AnimationOptions;
+export {};

package/atoms/ScrollAnimation/AbstractScrollAnimation.js

@@ -0,0 +1 @@
+import{Base as a,withFreezedOptions as n}from"@studiometa/js-toolkit";import{matrix as h,lerp as e,map as o,clamp as r}from"@studiometa/js-toolkit/utils";function i(){return{x:0,y:0,z:0,scale:1,scaleX:1,scaleY:1,rotate:0,skewX:0,skewY:0,opacity:1}}class l extends n(a){static config={name:"AbstractScrollAnimation",options:{playRange:{type:Array,default:()=>[0,1]},dampFactor:{type:Number,default:.5},dampPrecision:{type:Number,default:.001},from:{type:Object,default:i,merge:!0},to:{type:Object,default:i,merge:!0}}};get target(){return this.$el}get has(){const t={x:!1,y:!1,z:!1,scale:!1,scaleX:!1,scaleY:!1,rotate:!1,skewX:!1,skewY:!1,opacity:!1,transform:!1};return Object.keys(this.$options.from).forEach(s=>{t[s]=this.$options.from[s]!==this.$options.to[s]}),t.transform=Object.keys(t).filter(s=>s!=="opacity"&&s!=="transform").some(s=>t[s]),Object.defineProperty(this,"has",{value:t}),t}scrolledInView(t){if(!this.has.opacity&&!this.has.transform)return;const s=o(r(t.dampedProgress.y,this.$options.playRange[0],this.$options.playRange[1]),this.$options.playRange[0],this.$options.playRange[1],0,1);this.render(s)}render(t){if(this.has.opacity&&(this.target.style.opacity=String(o(t,0,1,this.$options.from.opacity,this.$options.to.opacity))),this.has.transform){let s=h({translateX:this.has.x?e(this.$options.from.x,this.$options.to.x,t):void 0,translateY:this.has.y?e(this.$options.from.y,this.$options.to.y,t):void 0,scaleX:this.has.scale?e(this.$options.from.scale,this.$options.to.scale,t):this.has.scaleX?e(this.$options.from.scaleX,this.$options.to.scaleX,t):void 0,scaleY:this.has.scale?e(this.$options.from.scale,this.$options.to.scale,t):this.has.scaleY?e(this.$options.from.scaleY,this.$options.to.scaleY,t):void 0,skewX:this.has.skewX?e(this.$options.from.skewX,this.$options.to.skewX,t):void 0,skewY:this.has.skewY?e(this.$options.from.skewY,this.$options.to.skewY,t):void 0});this.has.rotate&&(s+=` rotate(${e(this.$options.from.rotate,this.$options.to.rotate,t)}deg)`),s+=`translateZ(${this.has.z?e(this.$options.from.z,this.$options.to.z,t):0})`,this.target.style.transform=s}}}export{l as default};

package/atoms/ScrollAnimation/ScrollAnimation.cjs

@@ -0,0 +1,51 @@
+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 __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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);
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+
+// packages/ui/atoms/ScrollAnimation/ScrollAnimation.js
+var ScrollAnimation_exports = {};
+__export(ScrollAnimation_exports, {
+  default: () => ScrollAnimation
+});
+module.exports = __toCommonJS(ScrollAnimation_exports);
+var import_js_toolkit = require("@studiometa/js-toolkit");
+var import_AbstractScrollAnimation = __toESM(require("./AbstractScrollAnimation.cjs"), 1);
+var ScrollAnimation = class extends (0, import_js_toolkit.withScrolledInView)(import_AbstractScrollAnimation.default, {}) {
+  get target() {
+    return this.$refs.target;
+  }
+  get dampFactor() {
+    return this.$options.dampFactor;
+  }
+  get dampPrecision() {
+    return this.$options.dampPrecision;
+  }
+};
+__publicField(ScrollAnimation, "config", {
+  ...import_AbstractScrollAnimation.default.config,
+  name: "ScrollAnimation",
+  refs: ["target"]
+});
+if (module.exports.default) module.exports = module.exports.default;

package/atoms/ScrollAnimation/ScrollAnimation.d.ts

@@ -0,0 +1,55 @@
+/**
+ * @typedef {ScrollAnimation & { $refs: { target: HTMLElement }}} ScrollAnimationInterface
+ */
+/**
+ * ScrollAnimation class.
+ */
+export default class ScrollAnimation extends AbstractScrollAnimation {
+    /**
+     * Config.
+     */
+    static config: {
+        name: string;
+        refs: string[];
+        options: {
+            playRange: {
+                type: ArrayConstructor;
+                default: () => number[];
+            };
+            dampFactor: {
+                type: NumberConstructor;
+                default: number;
+            };
+            dampPrecision: {
+                type: NumberConstructor;
+                default: number;
+            };
+            from: {
+                type: ObjectConstructor;
+                default: () => import("./AbstractScrollAnimation.js").AnimationOptions;
+                merge: boolean;
+            };
+            to: {
+                type: ObjectConstructor;
+                default: () => import("./AbstractScrollAnimation.js").AnimationOptions;
+                merge: boolean;
+            };
+        };
+    };
+    /**
+     * Get the damp factor from the freezed options.
+     * @returns {number}
+     */
+    get dampFactor(): number;
+    /**
+     * Get the damp precision from the freezed options.
+     * @returns {number}
+     */
+    get dampPrecision(): number;
+}
+export type ScrollAnimationInterface = ScrollAnimation & {
+    $refs: {
+        target: HTMLElement;
+    };
+};
+import AbstractScrollAnimation from "./AbstractScrollAnimation.js";

package/atoms/ScrollAnimation/ScrollAnimation.js

@@ -0,0 +1 @@
+import{withScrolledInView as r}from"@studiometa/js-toolkit";import t from"./AbstractScrollAnimation.js";class i extends r(t,{}){static config={...t.config,name:"ScrollAnimation",refs:["target"]};get target(){return this.$refs.target}get dampFactor(){return this.$options.dampFactor}get dampPrecision(){return this.$options.dampPrecision}}export{i as default};

package/atoms/ScrollAnimation/ScrollAnimationChild.cjs

@@ -0,0 +1,51 @@
+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 __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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);
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+
+// packages/ui/atoms/ScrollAnimation/ScrollAnimationChild.js
+var ScrollAnimationChild_exports = {};
+__export(ScrollAnimationChild_exports, {
+  default: () => ScrollAnimationChild
+});
+module.exports = __toCommonJS(ScrollAnimationChild_exports);
+var import_utils = require("@studiometa/js-toolkit/utils");
+var import_AbstractScrollAnimation = __toESM(require("./AbstractScrollAnimation.cjs"), 1);
+var ScrollAnimationChild = class extends import_AbstractScrollAnimation.default {
+  dampedProgress = {
+    x: 0,
+    y: 0
+  };
+  scrolledInView(props) {
+    this.dampedProgress.y = (0, import_utils.damp)(props.progress.y, this.dampedProgress.y, this.$options.dampFactor, this.$options.dampPrecision);
+    this.dampedProgress.x = (0, import_utils.damp)(props.progress.x, this.dampedProgress.x, this.$options.dampFactor, this.$options.dampPrecision);
+    props.dampedProgress = this.dampedProgress;
+    super.scrolledInView(props);
+  }
+};
+__publicField(ScrollAnimationChild, "config", {
+  name: "ScrollAnimationChild",
+  ...import_AbstractScrollAnimation.default.config
+});
+if (module.exports.default) module.exports = module.exports.default;

package/atoms/ScrollAnimation/ScrollAnimationChild.d.ts

@@ -0,0 +1,13 @@
+/**
+ * ScrollAnimationChild class.
+ */
+export default class ScrollAnimationChild extends AbstractScrollAnimation {
+    /**
+     * Local damped progress.
+     */
+    dampedProgress: {
+        x: number;
+        y: number;
+    };
+}
+import AbstractScrollAnimation from "./AbstractScrollAnimation.js";

package/atoms/ScrollAnimation/ScrollAnimationChild.js

@@ -0,0 +1 @@
+import{damp as o}from"@studiometa/js-toolkit/utils";import i from"./AbstractScrollAnimation.js";class r extends i{static config={name:"ScrollAnimationChild",...i.config};dampedProgress={x:0,y:0};scrolledInView(s){this.dampedProgress.y=o(s.progress.y,this.dampedProgress.y,this.$options.dampFactor,this.$options.dampPrecision),this.dampedProgress.x=o(s.progress.x,this.dampedProgress.x,this.$options.dampFactor,this.$options.dampPrecision),s.dampedProgress=this.dampedProgress,super.scrolledInView(s)}}export{r as default};

package/atoms/ScrollAnimation/ScrollAnimationChildWithEase.cjs

@@ -0,0 +1,41 @@
+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 __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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);
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+
+// packages/ui/atoms/ScrollAnimation/ScrollAnimationChildWithEase.js
+var ScrollAnimationChildWithEase_exports = {};
+__export(ScrollAnimationChildWithEase_exports, {
+  default: () => ScrollAnimationChildWithEase
+});
+module.exports = __toCommonJS(ScrollAnimationChildWithEase_exports);
+var import_ScrollAnimationChild = __toESM(require("./ScrollAnimationChild.cjs"), 1);
+var import_animationScrollWithEase = __toESM(require("./animationScrollWithEase.cjs"), 1);
+var ScrollAnimationChildWithEase = class extends (0, import_animationScrollWithEase.default)(import_ScrollAnimationChild.default) {
+};
+__publicField(ScrollAnimationChildWithEase, "config", {
+  ...import_ScrollAnimationChild.default.config,
+  name: "ScrollAnimationChildWithEase"
+});
+if (module.exports.default) module.exports = module.exports.default;

package/atoms/ScrollAnimation/ScrollAnimationChildWithEase.d.ts

@@ -0,0 +1,6 @@
+/**
+ * ScrollAnimationChild class.
+ */
+export default class ScrollAnimationChildWithEase extends ScrollAnimationChild {
+}
+import ScrollAnimationChild from "./ScrollAnimationChild.js";

package/atoms/ScrollAnimation/ScrollAnimationChildWithEase.js

@@ -0,0 +1 @@
+import i from"./ScrollAnimationChild.js";import o from"./animationScrollWithEase.js";class t extends o(i){static config={...i.config,name:"ScrollAnimationChildWithEase"}}export{t as default};

package/atoms/ScrollAnimation/ScrollAnimationParent.cjs

@@ -0,0 +1,48 @@
+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 __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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);
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+
+// packages/ui/atoms/ScrollAnimation/ScrollAnimationParent.js
+var ScrollAnimationParent_exports = {};
+__export(ScrollAnimationParent_exports, {
+  default: () => ScrollAnimationParent
+});
+module.exports = __toCommonJS(ScrollAnimationParent_exports);
+var import_js_toolkit = require("@studiometa/js-toolkit");
+var import_ScrollAnimationChild = __toESM(require("./ScrollAnimationChild.cjs"), 1);
+var ScrollAnimationParent = class extends (0, import_js_toolkit.withScrolledInView)(import_js_toolkit.Base, {}) {
+  scrolledInView(props) {
+    this.$children.ScrollAnimationChild.forEach((child) => {
+      child.scrolledInView(props);
+    });
+  }
+};
+__publicField(ScrollAnimationParent, "config", {
+  name: "ScrollAnimationParent",
+  components: {
+    ScrollAnimationChild: import_ScrollAnimationChild.default
+  }
+});
+if (module.exports.default) module.exports = module.exports.default;

package/atoms/ScrollAnimation/ScrollAnimationParent.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @typedef {ScrollAnimationParent & {
+ *   $children: {
+ *     ScrollAnimationChild: ScrollAnimationChild[],
+ *   },
+ * }} ScrollAnimationInterface
+ */
+/**
+ * ScrollAnimationParent class.
+ */
+export default class ScrollAnimationParent extends Base {
+    /**
+     * Config.
+     */
+    static config: {
+        name: string;
+        components: {
+            ScrollAnimationChild: typeof ScrollAnimationChild;
+        };
+    };
+    /**
+     * @todo Optimize default value read
+     * @todo do not add unnecessary styles
+     * @todo freeze options for better perf
+     * @this {ScrollAnimationInterface}
+     */
+    scrolledInView(this: ScrollAnimationInterface, props: any): void;
+}
+export type ScrollAnimationInterface = ScrollAnimationParent & {
+    $children: {
+        ScrollAnimationChild: ScrollAnimationChild[];
+    };
+};
+import { Base } from "@studiometa/js-toolkit";
+import ScrollAnimationChild from "./ScrollAnimationChild.js";

package/atoms/ScrollAnimation/ScrollAnimationParent.js

@@ -0,0 +1 @@
+import{Base as l,withScrolledInView as n}from"@studiometa/js-toolkit";import e from"./ScrollAnimationChild.js";class r extends n(l,{}){static config={name:"ScrollAnimationParent",components:{ScrollAnimationChild:e}};scrolledInView(i){this.$children.ScrollAnimationChild.forEach(o=>{o.scrolledInView(i)})}}export{r as default};

package/atoms/ScrollAnimation/ScrollAnimationWithEase.cjs

@@ -0,0 +1,41 @@
+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 __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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);
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+
+// packages/ui/atoms/ScrollAnimation/ScrollAnimationWithEase.js
+var ScrollAnimationWithEase_exports = {};
+__export(ScrollAnimationWithEase_exports, {
+  default: () => ScrollAnimationWithEase
+});
+module.exports = __toCommonJS(ScrollAnimationWithEase_exports);
+var import_ScrollAnimation = __toESM(require("./ScrollAnimation.cjs"), 1);
+var import_animationScrollWithEase = __toESM(require("./animationScrollWithEase.cjs"), 1);
+var ScrollAnimationWithEase = class extends (0, import_animationScrollWithEase.default)(import_ScrollAnimation.default) {
+};
+__publicField(ScrollAnimationWithEase, "config", {
+  ...import_ScrollAnimation.default.config,
+  name: "ScrollAnimationWithEase"
+});
+if (module.exports.default) module.exports = module.exports.default;

package/atoms/ScrollAnimation/ScrollAnimationWithEase.d.ts

@@ -0,0 +1,6 @@
+/**
+ * ScrollAnimation class.
+ */
+export default class ScrollAnimationWithEase extends ScrollAnimation {
+}
+import ScrollAnimation from "./ScrollAnimation.js";

package/atoms/ScrollAnimation/ScrollAnimationWithEase.js

@@ -0,0 +1 @@
+import i from"./ScrollAnimation.js";import o from"./animationScrollWithEase.js";class t extends o(i){static config={...i.config,name:"ScrollAnimationWithEase"}}export{t as default};

package/atoms/ScrollAnimation/animationScrollWithEase.cjs

@@ -0,0 +1,70 @@
+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/ui/atoms/ScrollAnimation/animationScrollWithEase.js
+var animationScrollWithEase_exports = {};
+__export(animationScrollWithEase_exports, {
+  default: () => animationScrollWithEase
+});
+module.exports = __toCommonJS(animationScrollWithEase_exports);
+var import_utils = require("@studiometa/js-toolkit/utils");
+var eases = {
+  outQuad: import_utils.easeOutQuad,
+  inQuad: import_utils.easeInQuad,
+  inOutQuad: import_utils.easeInOutQuad,
+  outCubic: import_utils.easeOutCubic,
+  inCubic: import_utils.easeInCubic,
+  inOutCubic: import_utils.easeInOutCubic,
+  outQuart: import_utils.easeOutQuart,
+  inQuart: import_utils.easeInQuart,
+  inOutQuart: import_utils.easeInOutQuart,
+  outQuint: import_utils.easeOutQuint,
+  inQuint: import_utils.easeInQuint,
+  inOutQuint: import_utils.easeInOutQuint,
+  outSine: import_utils.easeOutSine,
+  inSine: import_utils.easeInSine,
+  inOutSine: import_utils.easeInOutSine,
+  outCirc: import_utils.easeOutCirc,
+  inCirc: import_utils.easeInCirc,
+  inOutCirc: import_utils.easeInOutCirc,
+  outExpo: import_utils.easeOutExpo,
+  inExpo: import_utils.easeInExpo,
+  inOutExpo: import_utils.easeInOutExpo
+};
+function animationScrollWithEase(ScrollAnimation) {
+  return class extends ScrollAnimation {
+    static config = {
+      ...ScrollAnimation.config,
+      name: `${ScrollAnimation.config.name}WithEase`,
+      options: {
+        ...ScrollAnimation.config.options,
+        ease: {
+          type: String,
+          default: "outExpo"
+        }
+      }
+    };
+    render(progress) {
+      if (eases[this.$options.ease]) {
+        progress = eases[this.$options.ease](progress);
+      }
+      super.render(progress);
+    }
+  };
+}
+if (module.exports.default) module.exports = module.exports.default;

package/atoms/ScrollAnimation/animationScrollWithEase.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @typedef {import('./AbstractScrollAnimation.js').AbstractScrollAnimationConstructor} AbstractScrollAnimationConstructor
+ */
+/**
+ * Extend a `ScrollAnimation` component to use easings.
+ * @template {AbstractScrollAnimationConstructor} T
+ * @param   {T} ScrollAnimation A child class of the `AbstractScrollAnimation` class.
+ * @returns {T}
+ */
+export default function animationScrollWithEase<T extends typeof import("./AbstractScrollAnimation.js").default>(ScrollAnimation: T): T;
+export type AbstractScrollAnimationConstructor = import('./AbstractScrollAnimation.js').AbstractScrollAnimationConstructor;

package/atoms/ScrollAnimation/animationScrollWithEase.js

@@ -0,0 +1 @@
+import{easeOutQuad as n,easeInQuad as i,easeInOutQuad as a,easeOutCubic as s,easeInCubic as o,easeInOutCubic as O,easeOutQuart as c,easeInQuart as Q,easeInOutQuart as r,easeOutQuint as I,easeInQuint as p,easeInOutQuint as C,easeOutSine as d,easeInSine as f,easeInOutSine as x,easeOutCirc as E,easeInCirc as b,easeInOutCirc as S,easeOutExpo as h,easeInExpo as g,easeInOutExpo as $}from"@studiometa/js-toolkit/utils";const u={outQuad:n,inQuad:i,inOutQuad:a,outCubic:s,inCubic:o,inOutCubic:O,outQuart:c,inQuart:Q,inOutQuart:r,outQuint:I,inQuint:p,inOutQuint:C,outSine:d,inSine:f,inOutSine:x,outCirc:E,inCirc:b,inOutCirc:S,outExpo:h,inExpo:g,inOutExpo:$};function m(e){return class extends e{static config={...e.config,name:`${e.config.name}WithEase`,options:{...e.config.options,ease:{type:String,default:"outExpo"}}};render(t){u[this.$options.ease]&&(t=u[this.$options.ease](t)),super.render(t)}}}export{m as default};

package/atoms/ScrollAnimation/index.cjs

@@ -0,0 +1,41 @@
+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/ui/atoms/ScrollAnimation/index.js
+var ScrollAnimation_exports = {};
+__export(ScrollAnimation_exports, {
+  AbstractScrollAnimation: () => import_AbstractScrollAnimation.default,
+  ScrollAnimation: () => import_ScrollAnimation.default,
+  ScrollAnimationChild: () => import_ScrollAnimationChild.default,
+  ScrollAnimationChildWithEase: () => import_ScrollAnimationChildWithEase.default,
+  ScrollAnimationParent: () => import_ScrollAnimationParent.default,
+  ScrollAnimationWithEase: () => import_ScrollAnimationWithEase.default,
+  animationScrollWithEase: () => import_animationScrollWithEase.default
+});
+module.exports = __toCommonJS(ScrollAnimation_exports);
+var import_AbstractScrollAnimation = __toESM(require("./AbstractScrollAnimation.cjs"), 1);
+var import_animationScrollWithEase = __toESM(require("./animationScrollWithEase.cjs"), 1);
+var import_ScrollAnimation = __toESM(require("./ScrollAnimation.cjs"), 1);
+var import_ScrollAnimationWithEase = __toESM(require("./ScrollAnimationWithEase.cjs"), 1);
+var import_ScrollAnimationChild = __toESM(require("./ScrollAnimationChild.cjs"), 1);
+var import_ScrollAnimationChildWithEase = __toESM(require("./ScrollAnimationChildWithEase.cjs"), 1);
+var import_ScrollAnimationParent = __toESM(require("./ScrollAnimationParent.cjs"), 1);
+if (module.exports.default) module.exports = module.exports.default;

package/atoms/ScrollAnimation/index.d.ts

@@ -0,0 +1,7 @@
+export { default as AbstractScrollAnimation } from "./AbstractScrollAnimation.js";
+export { default as animationScrollWithEase } from "./animationScrollWithEase.js";
+export { default as ScrollAnimation } from "./ScrollAnimation.js";
+export { default as ScrollAnimationWithEase } from "./ScrollAnimationWithEase.js";
+export { default as ScrollAnimationChild } from "./ScrollAnimationChild.js";
+export { default as ScrollAnimationChildWithEase } from "./ScrollAnimationChildWithEase.js";
+export { default as ScrollAnimationParent } from "./ScrollAnimationParent.js";

package/atoms/ScrollAnimation/index.js

@@ -0,0 +1 @@
+import{default as t}from"./AbstractScrollAnimation.js";import{default as r}from"./animationScrollWithEase.js";import{default as e}from"./ScrollAnimation.js";import{default as f}from"./ScrollAnimationWithEase.js";import{default as s}from"./ScrollAnimationChild.js";import{default as c}from"./ScrollAnimationChildWithEase.js";import{default as u}from"./ScrollAnimationParent.js";export{t as AbstractScrollAnimation,e as ScrollAnimation,s as ScrollAnimationChild,c as ScrollAnimationChildWithEase,u as ScrollAnimationParent,f as ScrollAnimationWithEase,r as animationScrollWithEase};