@maas/vue-equipment 1.2.0 → 1.4.0

package/dist/plugins/MagicDotMatrix/src/utils/emoji/motions.mjs

@@ -0,0 +1,420 @@
+function oscillate({ progress, cycles = 1, phase = 0 }) {
+  return Math.sin(Math.PI * 2 * (progress * cycles + phase));
+}
+function pulse({ progress, from, to }) {
+  return progress < from || progress > to ? 0 : Math.sin(Math.PI * (progress - from) / (to - from));
+}
+function easeOut(progress) {
+  return 1 - (1 - progress) ** 3;
+}
+function drift({ progress, offset }) {
+  return (progress + offset) % 1;
+}
+function streaks({ progress, heading, color }) {
+  const angle = heading * Math.PI / 180;
+  const backX = -Math.cos(angle);
+  const backY = -Math.sin(angle);
+  return [-0.3, 0, 0.3].map((lane, index) => {
+    const travel = drift({ progress, offset: index / 3 }) * 1.4 - 0.7;
+    return {
+      x: 0.5 - backY * lane + backX * travel,
+      y: 0.5 + backX * lane + backY * travel,
+      color
+    };
+  });
+}
+export const motions = {
+  beat: {
+    frames: 16,
+    interval: 70,
+    fit: 0.84,
+    pose: ({ progress }) => ({
+      scale: 1 + 0.16 * pulse({ progress, from: 0, to: 0.14 }) + 0.1 * pulse({ progress, from: 0.2, to: 0.32 })
+    })
+  },
+  flicker: {
+    frames: 12,
+    interval: 90,
+    fit: 0.9,
+    pose: ({ progress }) => ({
+      pivot: [0.5, 1],
+      scaleY: 1 + 0.07 * oscillate({ progress, cycles: 2 }) + 0.04 * oscillate({ progress, cycles: 5, phase: 0.3 }),
+      skew: 0.12 * oscillate({ progress, phase: 0.1 })
+    }),
+    particles: ({ progress }) => [0, 0.5].map((offset) => {
+      const rise = drift({ progress: progress * 1.5, offset });
+      return {
+        x: 0.7 + Math.sin(rise * 9) * 0.08,
+        y: 0.3 - rise * 0.4,
+        color: "#ffd24a"
+      };
+    })
+  },
+  swing: {
+    frames: 20,
+    interval: 70,
+    fit: 0.84,
+    pose: ({ progress }) => ({
+      pivot: [0.5, 0],
+      rotate: 22 * oscillate({ progress })
+    })
+  },
+  wave: {
+    frames: 20,
+    interval: 70,
+    fit: 0.74,
+    pose: ({ progress }) => ({
+      pivot: [0.5, 1],
+      y: 0.06,
+      rotate: progress < 0.6 ? 20 * oscillate({ progress: progress / 0.6, cycles: 2 }) : 0
+    })
+  },
+  fly: {
+    frames: 10,
+    interval: 80,
+    fit: 0.86,
+    pose: ({ progress, heading }) => {
+      const angle = (heading + 90) * Math.PI / 180;
+      return {
+        x: 0.025 * Math.cos(angle) * oscillate({ progress }),
+        y: 0.025 * Math.sin(angle) * oscillate({ progress })
+      };
+    },
+    particles: ({ progress, heading }) => streaks({ progress, heading, color: "#8a90b8" })
+  },
+  drive: {
+    frames: 8,
+    interval: 80,
+    fit: 0.78,
+    pose: ({ index }) => ({ y: index % 4 === 0 ? 0.045 : 0.07 }),
+    particles: ({ progress, heading }) => {
+      const behind = Math.cos(heading * Math.PI / 180) < 0 ? 1 : -1;
+      const lines = [0.29, 0.51].map((y, index) => {
+        const travel = drift({ progress, offset: index / 2 }) * 0.2;
+        return {
+          x: behind > 0 ? 0.8 + travel : 0.2 - travel,
+          y,
+          color: "#8a90b8"
+        };
+      });
+      const road = [0.05, 0.35, 0.65, 0.95].map((x) => ({
+        x: ((x + behind * progress * 0.3) % 1 + 1) % 1,
+        y: 0.95,
+        color: "#4c5070"
+      }));
+      return [...lines, ...road];
+    }
+  },
+  bounce: {
+    frames: 14,
+    interval: 70,
+    fit: 0.72,
+    pose: ({ progress }) => {
+      const landed = progress < 0.08 || progress > 0.92;
+      return {
+        pivot: [0.5, 1],
+        y: 0.14 - 0.26 * Math.sin(Math.PI * progress),
+        scaleX: landed ? 1.12 : 1,
+        scaleY: landed ? 0.85 : 1
+      };
+    }
+  },
+  hop: {
+    frames: 18,
+    interval: 70,
+    fit: 0.8,
+    pose: ({ progress }) => ({
+      pivot: [0.5, 1],
+      y: 0.1 - 0.14 * (pulse({ progress, from: 0, to: 0.22 }) + pulse({ progress, from: 0.26, to: 0.48 }))
+    })
+  },
+  spin: {
+    frames: 16,
+    interval: 70,
+    fit: 0.9,
+    pose: ({ progress }) => ({ rotate: 360 * progress })
+  },
+  flip: {
+    frames: 16,
+    interval: 70,
+    fit: 0.9,
+    pose: ({ progress }) => {
+      const turn = Math.cos(Math.PI * 2 * progress);
+      return { scaleX: Math.sign(turn || 1) * Math.max(0.2, Math.abs(turn)) };
+    }
+  },
+  float: {
+    frames: 20,
+    interval: 80,
+    fit: 0.82,
+    pose: ({ progress }) => ({
+      y: 0.07 * oscillate({ progress }),
+      rotate: 5 * oscillate({ progress, phase: 0.25 })
+    })
+  },
+  twinkle: {
+    frames: 16,
+    interval: 80,
+    fit: 0.8,
+    pose: ({ progress }) => ({
+      scale: 1 + 0.08 * oscillate({ progress, cycles: 2 })
+    }),
+    particles: ({ progress }) => [
+      { x: 0.11, y: 0.13, offset: 0 },
+      { x: 0.91, y: 0.17, offset: 0.33 },
+      { x: 0.88, y: 0.9, offset: 0.66 },
+      { x: 0.14, y: 0.87, offset: 0.5 }
+    ].flatMap(
+      ({ x, y, offset }) => drift({ progress, offset }) < 0.3 ? [{ x, y, color: "#fff" }] : []
+    )
+  },
+  shake: {
+    frames: 16,
+    interval: 60,
+    fit: 0.86,
+    pose: ({ progress, index }) => {
+      const side = index % 2 ? 1 : -1;
+      return progress < 0.5 ? { x: 0.045 * side, rotate: 4 * side } : {};
+    }
+  },
+  rain: {
+    frames: 12,
+    interval: 80,
+    fit: 0.68,
+    pose: () => ({ y: -0.14 }),
+    particles: ({ progress, tint }) => [
+      { x: 0.25, offset: 0 },
+      { x: 0.45, offset: 0.5 },
+      { x: 0.65, offset: 0.25 },
+      { x: 0.85, offset: 0.75 }
+    ].map(({ x, offset }) => ({
+      x,
+      y: 0.61 + drift({ progress, offset }) * 0.4,
+      color: tint ?? "#5aa7ff"
+    }))
+  },
+  snow: {
+    frames: 20,
+    interval: 90,
+    fit: 0.8,
+    pose: () => ({ y: 0.09 }),
+    particles: ({ progress }) => [
+      { x: 0.15, offset: 0 },
+      { x: 0.4, offset: 0.6 },
+      { x: 0.65, offset: 0.3 },
+      { x: 0.9, offset: 0.85 }
+    ].map(({ x, offset }) => {
+      const fall = drift({ progress, offset });
+      return {
+        x: x + Math.sin(fall * 6 + offset * 10) * 0.06,
+        y: fall * 1.1 - 0.05,
+        color: "#fff"
+      };
+    })
+  },
+  sleep: {
+    frames: 20,
+    interval: 90,
+    fit: 0.74,
+    pose: ({ progress }) => ({
+      x: -0.1,
+      y: 0.12 + 0.015 * oscillate({ progress })
+    }),
+    particles: ({ progress }) => [0, 0.5].map((offset) => {
+      const rise = drift({ progress, offset });
+      return {
+        x: 0.65 + rise * 0.3 + Math.sin(rise * 12) * 0.04,
+        y: 0.4 - rise * 0.35,
+        color: "#fff"
+      };
+    })
+  },
+  rock: {
+    frames: 12,
+    interval: 70,
+    fit: 0.86,
+    pose: ({ progress }) => ({
+      pivot: [0.5, 0.9],
+      rotate: 12 * oscillate({ progress, cycles: 2 })
+    })
+  },
+  burst: {
+    frames: 18,
+    interval: 70,
+    fit: 0.78,
+    pose: ({ progress }) => ({
+      scale: progress < 0.15 ? 0.8 + 0.3 * easeOut(progress / 0.15) : 1.1 - 0.1 * Math.min(1, (progress - 0.15) * 5)
+    }),
+    particles: ({ progress }) => {
+      const colors = ["#ff5aa5", "#ffd24a", "#4ad8ff", "#7cff6b"];
+      return Array.from({ length: 8 }, (_, index) => {
+        const angle = index / 8 * Math.PI * 2 + 0.3;
+        const radius = 0.2 + progress * 0.45;
+        return {
+          x: 0.5 + Math.cos(angle) * radius,
+          y: 0.5 + Math.sin(angle) * radius,
+          color: colors[index % colors.length] ?? "#fff"
+        };
+      });
+    }
+  },
+  stamp: {
+    frames: 30,
+    interval: 70,
+    fit: 0.86,
+    shine: [0.35, 0.65],
+    pose: ({ progress }) => {
+      if (progress < 0.12) {
+        return { scale: 1.5 - 0.6 * easeOut(progress / 0.12) };
+      }
+      if (progress < 0.2) {
+        return { scale: 0.9 + 0.1 * easeOut((progress - 0.12) / 0.08) };
+      }
+      return {};
+    }
+  },
+  gleam: {
+    frames: 28,
+    interval: 70,
+    fit: 0.86,
+    shine: [0.3, 0.6],
+    pose: ({ progress }) => ({ y: 0.02 * oscillate({ progress }) })
+  },
+  flag: {
+    frames: 12,
+    interval: 80,
+    fit: 0.9,
+    pose: ({ progress }) => ({ ripple: { amplitude: 0.07, phase: progress } })
+  },
+  sway: {
+    frames: 24,
+    interval: 80,
+    fit: 0.88,
+    pose: ({ progress }) => ({
+      pivot: [0.5, 1],
+      rotate: 7 * oscillate({ progress })
+    })
+  },
+  love: {
+    frames: 20,
+    interval: 80,
+    fit: 0.78,
+    pose: ({ progress }) => ({
+      y: 0.06 + 0.03 * oscillate({ progress, cycles: 2 })
+    }),
+    particles: ({ progress }) => [
+      { x: 0.15, offset: 0 },
+      { x: 0.87, offset: 0.5 }
+    ].map(({ x, offset }) => {
+      const rise = drift({ progress, offset });
+      return {
+        x: x + Math.sin(rise * 10) * 0.04,
+        y: 0.75 - rise * 0.7,
+        color: "#ff4f8b"
+      };
+    })
+  },
+  steam: {
+    frames: 16,
+    interval: 90,
+    fit: 0.72,
+    pose: () => ({ y: 0.14 }),
+    particles: ({ progress }) => [0.4, 0.6].map((x, index) => {
+      const rise = drift({ progress, offset: index / 2 });
+      return {
+        x: x + Math.sin(rise * 8 + index) * 0.06,
+        y: 0.35 - rise * 0.3,
+        color: "#d9d9d9"
+      };
+    })
+  },
+  look: {
+    frames: 24,
+    interval: 80,
+    fit: 0.86,
+    pose: ({ progress }) => {
+      if (progress >= 0.2 && progress < 0.45) {
+        return { x: -0.07 };
+      }
+      if (progress >= 0.55 && progress < 0.8) {
+        return { x: 0.07 };
+      }
+      return {};
+    }
+  },
+  nod: {
+    frames: 16,
+    interval: 70,
+    fit: 0.86,
+    pose: ({ progress }) => ({
+      y: 0.06 * (pulse({ progress, from: 0, to: 0.18 }) + pulse({ progress, from: 0.22, to: 0.4 }))
+    })
+  },
+  tilt: {
+    frames: 24,
+    interval: 80,
+    fit: 0.84,
+    pose: ({ progress }) => {
+      const lean = progress < 0.3 ? easeOut(progress / 0.3) : progress < 0.7 ? 1 : 1 - easeOut((progress - 0.7) / 0.3);
+      return { pivot: [0.5, 1], x: 0.04 * lean, rotate: 20 * lean };
+    }
+  },
+  swim: {
+    frames: 20,
+    interval: 80,
+    fit: 0.8,
+    pose: ({ progress }) => ({
+      x: 0.09 * oscillate({ progress }),
+      y: 0.03 * oscillate({ progress, cycles: 2 }),
+      rotate: 6 * oscillate({ progress, cycles: 2 })
+    }),
+    particles: ({ progress }) => [
+      {
+        x: 0.2,
+        y: 0.65 - drift({ progress: progress * 2, offset: 0 }) * 0.6,
+        color: "#a8dcff"
+      }
+    ]
+  },
+  flap: {
+    frames: 12,
+    interval: 70,
+    fit: 0.84,
+    pose: ({ progress }) => ({
+      scaleX: 1 - 0.35 * Math.abs(oscillate({ progress, cycles: 2 })),
+      y: 0.04 * oscillate({ progress })
+    })
+  },
+  clap: {
+    frames: 10,
+    interval: 70,
+    fit: 0.84,
+    pose: ({ progress }) => ({
+      scaleX: 1 - 0.25 * pulse({ progress, from: 0, to: 0.5 })
+    })
+  },
+  bob: {
+    frames: 20,
+    interval: 80,
+    fit: 0.86,
+    pose: ({ progress }) => ({
+      y: 0.055 * oscillate({ progress }),
+      rotate: 6 * oscillate({ progress, phase: 0.25 })
+    })
+  },
+  pop: {
+    frames: 34,
+    interval: 70,
+    fit: 0.92,
+    shine: [0.4, 0.68],
+    pose: ({ progress }) => {
+      if (progress < 0.12) {
+        return { scale: easeOut(progress / 0.12) };
+      }
+      if (progress > 0.9) {
+        return { scale: 1 - easeOut((progress - 0.9) / 0.1) };
+      }
+      return {};
+    }
+  }
+};

package/dist/plugins/MagicDotMatrix/src/utils/emoji/pickMotion.d.ts

@@ -0,0 +1,7 @@
+import type { DotMatrixEmojiMotion } from '../../types/index.js';
+export type EmojiMotionPick = {
+    name: DotMatrixEmojiMotion;
+    heading: number;
+    tint: string | undefined;
+};
+export declare function pickMotion(emoji: string): EmojiMotionPick;

package/dist/plugins/MagicDotMatrix/src/utils/emoji/pickMotion.mjs

@@ -0,0 +1,153 @@
+const curated = {
+  beat: "\u2764\u{1F9E1}\u{1F49B}\u{1F49A}\u{1F499}\u{1F49C}\u{1F5A4}\u{1F90D}\u{1F90E}\u{1FA77}\u{1FA75}\u{1FA76}\u{1F493}\u{1F497}\u{1F496}\u{1F498}\u{1F49D}\u{1F49E}\u{1F495}\u2763\u{1F494}\u{1FAC0}\u2665\u{1F4AA}",
+  flicker: "\u{1F525}\u{1F56F}\u{1FA94}\u{1F9E8}",
+  swing: "\u{1F514}\u{1F6CE}\u{1F390}\u{1F3EE}\u{1FA87}",
+  wave: "\u{1F44B}\u{1F590}\u270B\u{1F91A}\u{1F64B}\u{1FAF1}\u{1FAF2}",
+  fly: "\u{1F680}\u2708\u{1F6E9}\u{1F6F8}\u{1F681}\u{1F6EB}\u{1FA82}\u{1F985}\u{1F54A}\u{1F426}\u{1F986}\u{1F989}\u{1F409}\u{1F9F9}\u2604",
+  drive: "\u{1F697}\u{1F695}\u{1F699}\u{1F68C}\u{1F68E}\u{1F3CE}\u{1F693}\u{1F691}\u{1F692}\u{1F690}\u{1F6FB}\u{1F69A}\u{1F69B}\u{1F69C}\u{1F3CD}\u{1F6F5}\u{1F6B2}\u{1F6F4}\u{1F6F9}\u{1F682}\u{1F686}\u{1F684}\u{1F685}\u{1F688}\u{1F69D}\u{1F683}\u{1F68B}\u{1F69E}\u{1F696}\u{1F698}\u{1F68D}\u{1F694}\u{1F6FA}\u{1F9BD}\u{1F9BC}",
+  bounce: "\u26BD\u{1F3C0}\u{1F3C8}\u26BE\u{1F94E}\u{1F3BE}\u{1F3D0}\u{1F3C9}\u{1F3B1}\u{1FA80}\u{1F3D3}\u{1F94F}",
+  hop: "\u{1F438}\u{1F407}\u{1F430}\u{1F998}",
+  spin: "\u{1F300}\u{1F4BF}\u{1F4C0}\u2699\u{1F3A1}\u{1F365}\u{1F504}\u{1F503}\u{1F9FF}\u{1F6DE}\u{1F3A0}\u267B\u2744\u{1F635}\u200D\u{1F4AB}",
+  flip: "\u{1FA99}\u{1F0CF}\u{1F3B4}\u{1F004}\u{1F4B0}\u{1F52E}",
+  float: "\u{1F47B}\u{1F388}\u2601\u{1FAE7}\u{1FA81}\u{1F30D}\u{1F30E}\u{1F30F}\u{1F319}\u{1F31B}\u{1F31C}\u{1F31A}\u{1F31D}\u{1FA90}\u{1F6DF}\u{1F607}\u{1F47D}\u{1F9D1}\u200D\u{1F680}\u{1F468}\u200D\u{1F680}\u{1F469}\u200D\u{1F680}",
+  twinkle: "\u2B50\u{1F31F}\u2728\u{1F4AB}\u{1F320}\u{1F4A1}\u{1F506}\u2600\u{1F31E}",
+  shake: "\u{1F621}\u{1F92C}\u{1F620}\u{1F976}\u{1F631}\u{1F4F3}\u23F0\u{1F4F1}\u{1FAE8}\u26A1\u{1F30B}\u{1F44A}\u{1F91C}\u{1F91B}\u{1F381}",
+  rain: "\u{1F327}\u26C8\u{1F328}\u2614\u{1F326}",
+  snow: "\u2603\u26C4\u{1F3D4}\u{1F3BF}\u26F7\u{1F3C2}",
+  sleep: "\u{1F634}\u{1F4A4}\u{1F6CC}\u{1F971}\u{1F62A}",
+  rock: "\u{1F602}\u{1F923}\u{1F36E}\u{1FAE0}\u{1F3B8}\u{1F3B7}\u{1F941}\u{1F3B9}\u{1F3BA}\u{1FA97}\u{1F3BB}\u{1FA95}\u{1F3A4}\u{1F3A7}\u{1F3B6}\u{1F3B5}\u{1F57A}\u{1F483}\u{1F4A9}\u{1F92A}\u{1F61C}\u{1F61D}\u{1F643}\u{1F922}\u{1F92E}\u{1F480}\u{1F916}",
+  burst: "\u{1F389}\u{1F38A}\u{1F4A5}\u{1F386}\u{1F387}\u{1F37E}\u{1F382}\u{1F92F}\u{1F973}",
+  stamp: "\u{1F44D}\u{1F44E}\u2705\u2611\u2714\u{1F4AF}\u{1F197}\u{1F192}\u{1F3C6}\u{1F947}\u{1F948}\u{1F949}\u{1F396}\u{1F3C5}\u{1F44C}\u{1F91D}\u{1F64C}",
+  gleam: "\u{1F60E}\u{1F48E}\u{1F451}\u{1FAA9}\u{1F48D}",
+  flag: "\u{1F3F3}\u{1F3F4}\u{1F3C1}\u{1F38C}\u{1F6A9}\u{1F30A}",
+  sway: "\u{1F334}\u{1F335}\u{1F337}\u{1F339}\u{1F338}\u{1F33A}\u{1F33C}\u{1F33B}\u{1F331}\u{1F33F}\u2618\u{1F340}\u{1F38B}\u{1FAB4}\u{1F33E}\u{1F332}\u{1F333}\u{1F341}\u{1F342}\u{1F384}",
+  love: "\u{1F60D}\u{1F970}\u{1F618}\u{1F48C}\u{1FAF6}\u{1F63B}\u{1F48F}\u{1F491}",
+  steam: "\u2615\u{1F375}\u{1F35C}\u{1F372}\u2668\u{1FAD6}\u{1F958}\u{1F35D}\u{1FAD5}",
+  look: "\u{1F440}\u{1F441}\u{1F50D}\u{1F50E}\u{1F575}\u{1F449}\u{1F448}\u{1F642}\u200D\u2194\uFE0F",
+  nod: "\u{1F64F}\u{1F446}\u{1F447}\u261D\u{1F642}\u200D\u2195\uFE0F",
+  tilt: "\u{1F914}\u{1F928}\u{1F60F}\u{1F9D0}\u{1F644}\u{1F615}\u{1FAE4}",
+  swim: "\u{1F41F}\u{1F420}\u{1F421}\u{1F988}\u{1F433}\u{1F40B}\u{1F42C}\u{1F9AD}\u{1F419}\u{1F991}\u{1F990}\u{1F99E}\u{1F980}\u{1FABC}\u{1F40A}\u{1F422}",
+  flap: "\u{1F98B}\u{1F41D}\u{1FAB0}\u{1F99F}\u{1FABD}\u{1F987}",
+  clap: "\u{1F44F}",
+  bob: "",
+  pop: ""
+};
+const headings = {
+  "\u{1F680}": -45,
+  "\u2708": -30,
+  "\u{1F6E9}": -30,
+  "\u{1F6EB}": -30,
+  "\u{1F6F8}": 0,
+  "\u{1FA82}": 90,
+  "\u2604": 135
+};
+const tints = {
+  "\u{1F328}": "#fff"
+};
+const fallbacks = [
+  { name: "flag", ranges: [[127462, 127487]] },
+  {
+    name: "bob",
+    ranges: [
+      [128512, 128591],
+      [129296, 129327],
+      [129392, 129402],
+      [129760, 129775],
+      [129488, 129488]
+    ]
+  },
+  {
+    name: "wave",
+    ranges: [
+      [128074, 128080],
+      [128400, 128406],
+      [129304, 129311],
+      [129776, 129784],
+      [9994, 9997]
+    ]
+  },
+  {
+    name: "hop",
+    ranges: [
+      [128e3, 128063],
+      [129408, 129454],
+      [129712, 129727],
+      [129742, 129743]
+    ]
+  },
+  {
+    name: "bob",
+    ranges: [
+      [128102, 128135],
+      [129489, 129501],
+      [127939, 127948],
+      [128692, 128694],
+      [129340, 129342]
+    ]
+  },
+  { name: "drive", ranges: [[128640, 128709]] },
+  {
+    name: "rock",
+    ranges: [
+      [127789, 127871],
+      [129360, 129391],
+      [129472, 129483],
+      [129744, 129759]
+    ]
+  },
+  {
+    name: "float",
+    ranges: [
+      [127744, 127788],
+      [9728, 9983]
+    ]
+  }
+];
+const people = /^[\u{1F466}-\u{1F469}\u{1F9D1}\u{1F471}\u{1F46E}\u{1F477}]/u;
+let lookup;
+function normalize(emoji) {
+  return emoji.replace(/[\u{FE0F}\u{1F3FB}-\u{1F3FF}]/gu, "");
+}
+function isMotion(name) {
+  return name in curated;
+}
+function getLookup() {
+  if (lookup) {
+    return lookup;
+  }
+  const segmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+  lookup = new Map(
+    Object.entries(curated).flatMap(
+      ([name, list]) => isMotion(name) ? [...segmenter.segment(list)].map(
+        ({ segment }) => [
+          normalize(segment),
+          name
+        ]
+      ) : []
+    )
+  );
+  return lookup;
+}
+function matchCurated(emoji) {
+  const entries = getLookup();
+  const exact = entries.get(emoji);
+  if (exact || people.test(emoji)) {
+    return exact;
+  }
+  return emoji.split("\u200D").reverse().map((part) => entries.get(part)).find((name) => name !== void 0);
+}
+function matchRange(emoji) {
+  const codePoint = emoji.codePointAt(0) ?? 0;
+  return fallbacks.find(
+    ({ ranges }) => ranges.some(([from, to]) => codePoint >= from && codePoint <= to)
+  )?.name;
+}
+export function pickMotion(emoji) {
+  const base = normalize(emoji);
+  const name = matchCurated(base) ?? matchRange(base) ?? "pop";
+  return {
+    name,
+    heading: headings[base] ?? (name === "drive" ? 180 : 0),
+    tint: tints[base]
+  };
+}

package/dist/plugins/MagicDotMatrix/src/utils/presets/bounce.d.ts

@@ -0,0 +1,2 @@
+import type { DotMatrixGrid, DotMatrixSequence } from '../../types/index.js';
+export declare function createBounce({ cols, rows }: DotMatrixGrid): DotMatrixSequence;

package/dist/plugins/MagicDotMatrix/src/utils/presets/bounce.mjs

@@ -0,0 +1,8 @@
+export function createBounce({ cols, rows }) {
+  const forward = Array.from({ length: rows }, (_, row) => {
+    const indices = Array.from({ length: cols }, (__, col) => row * cols + col);
+    return row % 2 === 0 ? indices : [...indices].reverse();
+  });
+  const backward = [...forward].reverse().map((row) => [...row].reverse());
+  return [...forward, ...backward];
+}

package/dist/plugins/MagicDotMatrix/src/utils/presets/checkerboard.d.ts

@@ -0,0 +1,2 @@
+import type { DotMatrixGrid, DotMatrixSequence } from '../../types/index.js';
+export declare function createCheckerboard({ cols, rows, }: DotMatrixGrid): DotMatrixSequence;

package/dist/plugins/MagicDotMatrix/src/utils/presets/checkerboard.mjs

@@ -0,0 +1,18 @@
+export function createCheckerboard({
+  cols,
+  rows
+}) {
+  const even = [];
+  const odd = [];
+  for (let row = 0; row < rows; row++) {
+    for (let col = 0; col < cols; col++) {
+      const index = row * cols + col;
+      if ((row + col) % 2 === 0) {
+        even.push(index);
+      } else {
+        odd.push(index);
+      }
+    }
+  }
+  return [even, odd, even, odd];
+}

package/dist/plugins/MagicDotMatrix/src/utils/presets/comet.d.ts

@@ -0,0 +1,2 @@
+import type { DotMatrixGrid, DotMatrixSequence } from '../../types/index.js';
+export declare function createComet({ cols, rows }: DotMatrixGrid): DotMatrixSequence;

package/dist/plugins/MagicDotMatrix/src/utils/presets/comet.mjs

@@ -0,0 +1,5 @@
+import { ringPath } from "../sequence/ringPath.mjs";
+import { withTrail } from "../sequence/withTrail.mjs";
+export function createComet({ cols, rows }) {
+  return withTrail({ path: ringPath({ cols, rows }) });
+}

package/dist/plugins/MagicDotMatrix/src/utils/presets/drift.d.ts

@@ -0,0 +1,2 @@
+import type { DotMatrixGrid, DotMatrixSequence } from '../../types/index.js';
+export declare function createDrift({ cols, rows }: DotMatrixGrid): DotMatrixSequence;

package/dist/plugins/MagicDotMatrix/src/utils/presets/drift.mjs

@@ -0,0 +1,38 @@
+import { toIndex } from "../sequence/toIndex.mjs";
+function frameKey(frame) {
+  return frame.join(",");
+}
+export function createDrift({ cols, rows }) {
+  const frameCount = 48;
+  const originCol = (cols - 1) / 2;
+  const originRow = (rows - 1) / 2;
+  const frames = Array.from({ length: frameCount }, (_, tick) => {
+    const phase = tick / frameCount * Math.PI * 2;
+    const centerCol = originCol + (cols - 1) * 0.38 * Math.sin(phase);
+    const centerRow = originRow + (rows - 1) * 0.38 * Math.sin(phase * 2 + 1.05);
+    const radius = 1.9 + 0.5 * Math.sin(phase * 3 + 0.5);
+    const frame = [];
+    let core = 0;
+    let coreDistance = Infinity;
+    for (let row = 0; row < rows; row++) {
+      for (let col = 0; col < cols; col++) {
+        const distance = Math.hypot(col - centerCol, row - centerRow);
+        if (distance < coreDistance) {
+          coreDistance = distance;
+          core = toIndex({ col, row, cols });
+        }
+        if (distance <= radius) {
+          frame.push(toIndex({ col, row, cols }));
+        }
+      }
+    }
+    return frame.length > 0 ? frame : [core];
+  });
+  const moving = frames.filter(
+    (frame, index) => index === 0 || frameKey(frame) !== frameKey(frames[index - 1])
+  );
+  while (moving.length > 1 && frameKey(moving.at(-1)) === frameKey(moving[0])) {
+    moving.pop();
+  }
+  return moving;
+}

package/dist/plugins/MagicDotMatrix/src/utils/presets/equalizer.d.ts

@@ -0,0 +1,2 @@
+import type { DotMatrixGrid, DotMatrixSequence } from '../../types/index.js';
+export declare function createEqualizer({ cols, rows, }: DotMatrixGrid): DotMatrixSequence;

package/dist/plugins/MagicDotMatrix/src/utils/presets/equalizer.mjs

@@ -0,0 +1,14 @@
+import { equalizerFrame } from "../sequence/equalizerFrame.mjs";
+export function createEqualizer({
+  cols,
+  rows
+}) {
+  const frameCount = 12;
+  return Array.from({ length: frameCount }, (_, tick) => {
+    const heights = Array.from({ length: cols }, (__, col) => {
+      const wave = (Math.sin(tick / frameCount * Math.PI * 2 + col * 0.9) + 1) / 2;
+      return Math.max(1, Math.round(wave * rows));
+    });
+    return equalizerFrame({ heights, cols, rows });
+  });
+}

package/dist/plugins/MagicDotMatrix/src/utils/presets/fill.d.ts

@@ -0,0 +1,2 @@
+import type { DotMatrixGrid, DotMatrixSequence } from '../../types/index.js';
+export declare function createFill({ cols, rows }: DotMatrixGrid): DotMatrixSequence;