@octaviaflow/motion 1.0.0 → 1.1.3

package/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog
+
+All notable changes to `@octaviaflow/motion` will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.1.3] - 2026-02-07
+
+### Changed
+
+- Synchronized version to 1.1.3 across all OctaviaFlow Design System packages
+- Aligned package versioning for unified release

package/es/index.js

@@ -0,0 +1,56 @@
+const fast01 = "70ms";
+const fast02 = "110ms";
+const moderate01 = "150ms";
+const moderate02 = "240ms";
+const slow01 = "400ms";
+const slow02 = "700ms";
+const durationFast01 = fast01;
+const durationFast02 = fast02;
+const durationModerate01 = moderate01;
+const durationModerate02 = moderate02;
+const durationSlow01 = slow01;
+const durationSlow02 = slow02;
+const unstable_tokens = [
+  "fast01",
+  "fast02",
+  "moderate01",
+  "moderate02",
+  "slow01",
+  "slow02",
+  "durationFast01",
+  "durationFast02",
+  "durationModerate01",
+  "durationModerate02",
+  "durationSlow01",
+  "durationSlow02"
+];
+const easings = {
+  standard: {
+    productive: "cubic-bezier(0.2, 0, 0.38, 0.9)",
+    expressive: "cubic-bezier(0.4, 0.14, 0.3, 1)"
+  },
+  entrance: {
+    productive: "cubic-bezier(0, 0, 0.38, 0.9)",
+    expressive: "cubic-bezier(0, 0, 0.3, 1)"
+  },
+  exit: {
+    productive: "cubic-bezier(0.2, 0, 1, 0.9)",
+    expressive: "cubic-bezier(0.4, 0.14, 1, 1)"
+  }
+};
+function motion(name, mode) {
+  if (!easings[name]) {
+    throw new Error(
+      `Unable to find easing \`${name}\` in our supported easings. Expected One of: ${Object.keys(easings).join(", ")}`
+    );
+  }
+  const easing = easings[name];
+  if (!easing[mode]) {
+    throw new Error(
+      `Unable to find a mode for the easing \`${name}\` called: \`${mode}\``
+    );
+  }
+  return easing[mode];
+}
+
+export { durationFast01, durationFast02, durationModerate01, durationModerate02, durationSlow01, durationSlow02, easings, fast01, fast02, moderate01, moderate02, motion, slow01, slow02, unstable_tokens };

package/lib/index.js

@@ -2,50 +2,57 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-/**
- * Copyright OctaviaFlow
- * Author: Vishal Kumar
- * Created: 11/November/2025
- * 
- * This source code is licensed under the Apache-2.0 license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-var fast01 = '70ms';
-var fast02 = '110ms';
-var moderate01 = '150ms';
-var moderate02 = '240ms';
-var slow01 = '400ms';
-var slow02 = '700ms';
-// V11 Tokens
-var durationFast01 = fast01;
-var durationFast02 = fast02;
-var durationModerate01 = moderate01;
-var durationModerate02 = moderate02;
-var durationSlow01 = slow01;
-var durationSlow02 = slow02;
-var unstable_tokens = ['fast01', 'fast02', 'moderate01', 'moderate02', 'slow01', 'slow02', 'durationFast01', 'durationFast02', 'durationModerate01', 'durationModerate02', 'durationSlow01', 'durationSlow02'];
-var easings = {
+const fast01 = "70ms";
+const fast02 = "110ms";
+const moderate01 = "150ms";
+const moderate02 = "240ms";
+const slow01 = "400ms";
+const slow02 = "700ms";
+const durationFast01 = fast01;
+const durationFast02 = fast02;
+const durationModerate01 = moderate01;
+const durationModerate02 = moderate02;
+const durationSlow01 = slow01;
+const durationSlow02 = slow02;
+const unstable_tokens = [
+  "fast01",
+  "fast02",
+  "moderate01",
+  "moderate02",
+  "slow01",
+  "slow02",
+  "durationFast01",
+  "durationFast02",
+  "durationModerate01",
+  "durationModerate02",
+  "durationSlow01",
+  "durationSlow02"
+];
+const easings = {
   standard: {
-    productive: 'cubic-bezier(0.2, 0, 0.38, 0.9)',
-    expressive: 'cubic-bezier(0.4, 0.14, 0.3, 1)'
+    productive: "cubic-bezier(0.2, 0, 0.38, 0.9)",
+    expressive: "cubic-bezier(0.4, 0.14, 0.3, 1)"
   },
   entrance: {
-    productive: 'cubic-bezier(0, 0, 0.38, 0.9)',
-    expressive: 'cubic-bezier(0, 0, 0.3, 1)'
+    productive: "cubic-bezier(0, 0, 0.38, 0.9)",
+    expressive: "cubic-bezier(0, 0, 0.3, 1)"
   },
   exit: {
-    productive: 'cubic-bezier(0.2, 0, 1, 0.9)',
-    expressive: 'cubic-bezier(0.4, 0.14, 1, 1)'
+    productive: "cubic-bezier(0.2, 0, 1, 0.9)",
+    expressive: "cubic-bezier(0.4, 0.14, 1, 1)"
   }
 };
 function motion(name, mode) {
   if (!easings[name]) {
-    throw new Error("Unable to find easing `".concat(name, "` in our supported easings. Expected ") + "One of: ".concat(Object.keys(easings).join(', ')));
+    throw new Error(
+      `Unable to find easing \`${name}\` in our supported easings. Expected One of: ${Object.keys(easings).join(", ")}`
+    );
   }
-  var easing = easings[name];
+  const easing = easings[name];
   if (!easing[mode]) {
-    throw new Error("Unable to find a mode for the easing `".concat(name, "` called: `").concat(mode, "`"));
+    throw new Error(
+      `Unable to find a mode for the easing \`${name}\` called: \`${mode}\``
+    );
   }
   return easing[mode];
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@octaviaflow/motion",
   "description": "Motion helpers for digital and software products using the OctaviaFlow Design System",
-  "version": "1.0.0",
+  "version": "1.1.3",
   "license": "Apache-2.0",
   "main": "lib/index.js",
   "module": "es/index.js",
@@ -20,17 +20,14 @@
   "publishConfig": {
     "access": "public"
   },
-  "dependencies": {
-    "@babel/runtime": "^7.25.0"
-  },
+  "dependencies": {},
   "scripts": {
     "build": "bun run clean && octaviaflow-cli bundle src/index.js --name OctaviaFlowMotion",
-    "clean": "rimraf es lib umd"
+    "clean": "rimraf es lib umd",
+    "test": "bun test ."
   },
   "devDependencies": {
-    "@babel/core": "^7.28.6",
-    "@babel/preset-env": "^7.28.6",
-    "@octaviaflow/cli": "^1.0.0",
+    "@octaviaflow/cli": "^2.0.0",
     "rimraf": "^6.0.0"
   }
 }

package/src/__tests__/motion.test.js

@@ -0,0 +1,293 @@
+/**
+ * Copyright OctaviaFlow
+ * Author: Vishal Kumar
+ * Created: 31/January/2026
+ *
+ * This source code is licensed under the Apache-2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import { describe, it, expect } from "bun:test";
+import {
+  fast01,
+  fast02,
+  moderate01,
+  moderate02,
+  slow01,
+  slow02,
+  durationFast01,
+  durationFast02,
+  durationModerate01,
+  durationModerate02,
+  durationSlow01,
+  durationSlow02,
+  unstable_tokens,
+  easings,
+  motion,
+} from "../index.js";
+
+describe("Motion durations", () => {
+  describe("Legacy duration tokens", () => {
+    it("should export fast01", () => {
+      expect(fast01).toBe("70ms");
+    });
+
+    it("should export fast02", () => {
+      expect(fast02).toBe("110ms");
+    });
+
+    it("should export moderate01", () => {
+      expect(moderate01).toBe("150ms");
+    });
+
+    it("should export moderate02", () => {
+      expect(moderate02).toBe("240ms");
+    });
+
+    it("should export slow01", () => {
+      expect(slow01).toBe("400ms");
+    });
+
+    it("should export slow02", () => {
+      expect(slow02).toBe("700ms");
+    });
+  });
+
+  describe("V11 duration tokens", () => {
+    it("should export durationFast01 matching fast01", () => {
+      expect(durationFast01).toBe(fast01);
+      expect(durationFast01).toBe("70ms");
+    });
+
+    it("should export durationFast02 matching fast02", () => {
+      expect(durationFast02).toBe(fast02);
+      expect(durationFast02).toBe("110ms");
+    });
+
+    it("should export durationModerate01 matching moderate01", () => {
+      expect(durationModerate01).toBe(moderate01);
+      expect(durationModerate01).toBe("150ms");
+    });
+
+    it("should export durationModerate02 matching moderate02", () => {
+      expect(durationModerate02).toBe(moderate02);
+      expect(durationModerate02).toBe("240ms");
+    });
+
+    it("should export durationSlow01 matching slow01", () => {
+      expect(durationSlow01).toBe(slow01);
+      expect(durationSlow01).toBe("400ms");
+    });
+
+    it("should export durationSlow02 matching slow02", () => {
+      expect(durationSlow02).toBe(slow02);
+      expect(durationSlow02).toBe("700ms");
+    });
+  });
+
+  describe("Duration format", () => {
+    it("should have all durations in milliseconds", () => {
+      const durations = [
+        fast01,
+        fast02,
+        moderate01,
+        moderate02,
+        slow01,
+        slow02,
+      ];
+
+      durations.forEach((duration) => {
+        expect(duration).toMatch(/^\d+ms$/);
+      });
+    });
+
+    it("should have increasing duration values", () => {
+      const fast01Value = parseInt(fast01);
+      const fast02Value = parseInt(fast02);
+      const moderate01Value = parseInt(moderate01);
+      const moderate02Value = parseInt(moderate02);
+      const slow01Value = parseInt(slow01);
+      const slow02Value = parseInt(slow02);
+
+      expect(fast01Value).toBeLessThan(fast02Value);
+      expect(fast02Value).toBeLessThan(moderate01Value);
+      expect(moderate01Value).toBeLessThan(moderate02Value);
+      expect(moderate02Value).toBeLessThan(slow01Value);
+      expect(slow01Value).toBeLessThan(slow02Value);
+    });
+  });
+
+  describe("unstable_tokens", () => {
+    it("should export an array of token names", () => {
+      expect(Array.isArray(unstable_tokens)).toBe(true);
+      expect(unstable_tokens.length).toBe(12);
+    });
+
+    it("should include all legacy tokens", () => {
+      expect(unstable_tokens).toContain("fast01");
+      expect(unstable_tokens).toContain("fast02");
+      expect(unstable_tokens).toContain("moderate01");
+      expect(unstable_tokens).toContain("moderate02");
+      expect(unstable_tokens).toContain("slow01");
+      expect(unstable_tokens).toContain("slow02");
+    });
+
+    it("should include all V11 tokens", () => {
+      expect(unstable_tokens).toContain("durationFast01");
+      expect(unstable_tokens).toContain("durationFast02");
+      expect(unstable_tokens).toContain("durationModerate01");
+      expect(unstable_tokens).toContain("durationModerate02");
+      expect(unstable_tokens).toContain("durationSlow01");
+      expect(unstable_tokens).toContain("durationSlow02");
+    });
+  });
+});
+
+describe("Easings", () => {
+  describe("easings object structure", () => {
+    it("should export easings object", () => {
+      expect(easings).toBeDefined();
+      expect(typeof easings).toBe("object");
+    });
+
+    it("should have standard, entrance, and exit types", () => {
+      expect(easings.standard).toBeDefined();
+      expect(easings.entrance).toBeDefined();
+      expect(easings.exit).toBeDefined();
+    });
+
+    it("should have productive and expressive modes for each type", () => {
+      ["standard", "entrance", "exit"].forEach((type) => {
+        expect(easings[type].productive).toBeDefined();
+        expect(easings[type].expressive).toBeDefined();
+      });
+    });
+  });
+
+  describe("easing values", () => {
+    it("should have standard productive easing", () => {
+      expect(easings.standard.productive).toBe(
+        "cubic-bezier(0.2, 0, 0.38, 0.9)",
+      );
+    });
+
+    it("should have standard expressive easing", () => {
+      expect(easings.standard.expressive).toBe(
+        "cubic-bezier(0.4, 0.14, 0.3, 1)",
+      );
+    });
+
+    it("should have entrance productive easing", () => {
+      expect(easings.entrance.productive).toBe("cubic-bezier(0, 0, 0.38, 0.9)");
+    });
+
+    it("should have entrance expressive easing", () => {
+      expect(easings.entrance.expressive).toBe("cubic-bezier(0, 0, 0.3, 1)");
+    });
+
+    it("should have exit productive easing", () => {
+      expect(easings.exit.productive).toBe("cubic-bezier(0.2, 0, 1, 0.9)");
+    });
+
+    it("should have exit expressive easing", () => {
+      expect(easings.exit.expressive).toBe("cubic-bezier(0.4, 0.14, 1, 1)");
+    });
+  });
+
+  describe("easing format", () => {
+    it("should have all easings in cubic-bezier format", () => {
+      const cubicBezierRegex =
+        /^cubic-bezier\([0-9.]+,\s*[0-9.]+,\s*[0-9.]+,\s*[0-9.]+\)$/;
+
+      Object.values(easings).forEach((typeEasings) => {
+        Object.values(typeEasings).forEach((easing) => {
+          expect(easing).toMatch(cubicBezierRegex);
+        });
+      });
+    });
+  });
+});
+
+describe("motion function", () => {
+  describe("valid inputs", () => {
+    it("should return standard productive easing", () => {
+      expect(motion("standard", "productive")).toBe(
+        "cubic-bezier(0.2, 0, 0.38, 0.9)",
+      );
+    });
+
+    it("should return standard expressive easing", () => {
+      expect(motion("standard", "expressive")).toBe(
+        "cubic-bezier(0.4, 0.14, 0.3, 1)",
+      );
+    });
+
+    it("should return entrance productive easing", () => {
+      expect(motion("entrance", "productive")).toBe(
+        "cubic-bezier(0, 0, 0.38, 0.9)",
+      );
+    });
+
+    it("should return entrance expressive easing", () => {
+      expect(motion("entrance", "expressive")).toBe(
+        "cubic-bezier(0, 0, 0.3, 1)",
+      );
+    });
+
+    it("should return exit productive easing", () => {
+      expect(motion("exit", "productive")).toBe("cubic-bezier(0.2, 0, 1, 0.9)");
+    });
+
+    it("should return exit expressive easing", () => {
+      expect(motion("exit", "expressive")).toBe(
+        "cubic-bezier(0.4, 0.14, 1, 1)",
+      );
+    });
+  });
+
+  describe("error handling", () => {
+    it("should throw error for invalid easing name", () => {
+      expect(() => motion("invalid", "productive")).toThrow();
+      expect(() => motion("invalid", "productive")).toThrow(
+        /Unable to find easing/,
+      );
+    });
+
+    it("should throw error for invalid mode", () => {
+      expect(() => motion("standard", "invalid")).toThrow();
+      expect(() => motion("standard", "invalid")).toThrow(
+        /Unable to find a mode/,
+      );
+    });
+
+    it("should include available easings in error message", () => {
+      expect(() => motion("invalid", "productive")).toThrow(
+        /standard, entrance, exit/,
+      );
+    });
+
+    it("should mention the invalid easing name in error", () => {
+      expect(() => motion("wrong", "productive")).toThrow(/wrong/);
+    });
+
+    it("should mention the invalid mode in error", () => {
+      expect(() => motion("standard", "wrong")).toThrow(/wrong/);
+    });
+  });
+
+  describe("all combinations", () => {
+    it("should work for all valid type and mode combinations", () => {
+      const types = ["standard", "entrance", "exit"];
+      const modes = ["productive", "expressive"];
+
+      types.forEach((type) => {
+        modes.forEach((mode) => {
+          const result = motion(type, mode);
+          expect(result).toBeDefined();
+          expect(typeof result).toBe("string");
+          expect(result).toMatch(/^cubic-bezier/);
+        });
+      });
+    });
+  });
+});

package/umd/index.js

@@ -0,0 +1,80 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+  typeof define === 'function' && define.amd ? define(['exports'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.OctaviaFlowMotion = {}));
+})(this, (function (exports) { 'use strict';
+
+  const fast01 = "70ms";
+  const fast02 = "110ms";
+  const moderate01 = "150ms";
+  const moderate02 = "240ms";
+  const slow01 = "400ms";
+  const slow02 = "700ms";
+  const durationFast01 = fast01;
+  const durationFast02 = fast02;
+  const durationModerate01 = moderate01;
+  const durationModerate02 = moderate02;
+  const durationSlow01 = slow01;
+  const durationSlow02 = slow02;
+  const unstable_tokens = [
+    "fast01",
+    "fast02",
+    "moderate01",
+    "moderate02",
+    "slow01",
+    "slow02",
+    "durationFast01",
+    "durationFast02",
+    "durationModerate01",
+    "durationModerate02",
+    "durationSlow01",
+    "durationSlow02"
+  ];
+  const easings = {
+    standard: {
+      productive: "cubic-bezier(0.2, 0, 0.38, 0.9)",
+      expressive: "cubic-bezier(0.4, 0.14, 0.3, 1)"
+    },
+    entrance: {
+      productive: "cubic-bezier(0, 0, 0.38, 0.9)",
+      expressive: "cubic-bezier(0, 0, 0.3, 1)"
+    },
+    exit: {
+      productive: "cubic-bezier(0.2, 0, 1, 0.9)",
+      expressive: "cubic-bezier(0.4, 0.14, 1, 1)"
+    }
+  };
+  function motion(name, mode) {
+    if (!easings[name]) {
+      throw new Error(
+        `Unable to find easing \`${name}\` in our supported easings. Expected One of: ${Object.keys(easings).join(", ")}`
+      );
+    }
+    const easing = easings[name];
+    if (!easing[mode]) {
+      throw new Error(
+        `Unable to find a mode for the easing \`${name}\` called: \`${mode}\``
+      );
+    }
+    return easing[mode];
+  }
+
+  exports.durationFast01 = durationFast01;
+  exports.durationFast02 = durationFast02;
+  exports.durationModerate01 = durationModerate01;
+  exports.durationModerate02 = durationModerate02;
+  exports.durationSlow01 = durationSlow01;
+  exports.durationSlow02 = durationSlow02;
+  exports.easings = easings;
+  exports.fast01 = fast01;
+  exports.fast02 = fast02;
+  exports.moderate01 = moderate01;
+  exports.moderate02 = moderate02;
+  exports.motion = motion;
+  exports.slow01 = slow01;
+  exports.slow02 = slow02;
+  exports.unstable_tokens = unstable_tokens;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+}));