@motionscript/layout-grid 0.0.0-stage → 0.1.0-alpha.3

package/dist/kit/order.d.ts

@@ -0,0 +1,13 @@
+/**
+ * A grid's `order` lists items in slot order: slot `k` holds item `order[k]`.
+ * These keep it a permutation whatever it was written as — a stale entry past
+ * the count, a repeat, or nothing at all — so a child added or removed never
+ * leaves a slot empty or two items in one.
+ */
+/** `order` repaired into a permutation of `0..count-1`: its valid entries first, then the rest in item order. */
+export declare function normalizeOrder(order: readonly number[] | undefined, count: number): number[];
+/** For each item, the slot it sits in. */
+export declare function slotOfItem(order: readonly number[]): number[];
+/** An order written as `"2, 0, 1"` or as numbers. */
+export declare function parseOrder(value: unknown): number[];
+//# sourceMappingURL=order.d.ts.map

package/dist/kit/order.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"order.d.ts","sourceRoot":"","sources":["../../src/kit/order.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,iHAAiH;AACjH,wBAAgB,cAAc,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAY5F;AAED,0CAA0C;AAC1C,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAM7D;AAED,qDAAqD;AACrD,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,EAAE,CAQnD"}

package/dist/kit/order.js

@@ -0,0 +1,43 @@
+/**
+ * A grid's `order` lists items in slot order: slot `k` holds item `order[k]`.
+ * These keep it a permutation whatever it was written as — a stale entry past
+ * the count, a repeat, or nothing at all — so a child added or removed never
+ * leaves a slot empty or two items in one.
+ */
+/** `order` repaired into a permutation of `0..count-1`: its valid entries first, then the rest in item order. */
+export function normalizeOrder(order, count) {
+    const out = [];
+    const taken = new Array(count).fill(false);
+    for (const entry of order ?? []) {
+        const item = Math.round(entry);
+        if (item >= 0 && item < count && !taken[item]) {
+            taken[item] = true;
+            out.push(item);
+        }
+    }
+    for (let item = 0; item < count; item++)
+        if (!taken[item])
+            out.push(item);
+    return out;
+}
+/** For each item, the slot it sits in. */
+export function slotOfItem(order) {
+    const slots = new Array(order.length);
+    order.forEach((item, slot) => {
+        slots[item] = slot;
+    });
+    return slots;
+}
+/** An order written as `"2, 0, 1"` or as numbers. */
+export function parseOrder(value) {
+    if (Array.isArray(value))
+        return value.map(Number).filter(Number.isFinite);
+    if (typeof value !== "string")
+        return [];
+    return value
+        .split(/[\s,]+/)
+        .filter((part) => part !== "")
+        .map(Number)
+        .filter(Number.isFinite);
+}
+//# sourceMappingURL=order.js.map

package/dist/kit/order.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"order.js","sourceRoot":"","sources":["../../src/kit/order.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,iHAAiH;AACjH,MAAM,UAAU,cAAc,CAAC,KAAoC,EAAE,KAAa;IAChF,MAAM,GAAG,GAAa,EAAE,CAAA;IACxB,MAAM,KAAK,GAAG,IAAI,KAAK,CAAU,KAAK,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;IACnD,KAAK,MAAM,KAAK,IAAI,KAAK,IAAI,EAAE,EAAE,CAAC;QAChC,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAA;QAC9B,IAAI,IAAI,IAAI,CAAC,IAAI,IAAI,GAAG,KAAK,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;YAC9C,KAAK,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;YAClB,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;QAChB,CAAC;IACH,CAAC;IACD,KAAK,IAAI,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,EAAE,IAAI,EAAE;QAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC;YAAE,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IACzE,OAAO,GAAG,CAAA;AACZ,CAAC;AAED,0CAA0C;AAC1C,MAAM,UAAU,UAAU,CAAC,KAAwB;IACjD,MAAM,KAAK,GAAG,IAAI,KAAK,CAAS,KAAK,CAAC,MAAM,CAAC,CAAA;IAC7C,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,EAAE;QAC3B,KAAK,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;IACpB,CAAC,CAAC,CAAA;IACF,OAAO,KAAK,CAAA;AACd,CAAC;AAED,qDAAqD;AACrD,MAAM,UAAU,UAAU,CAAC,KAAc;IACvC,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAA;IAC1E,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,EAAE,CAAA;IACxC,OAAO,KAAK;SACT,KAAK,CAAC,QAAQ,CAAC;SACf,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,KAAK,EAAE,CAAC;SAC7B,GAAG,CAAC,MAAM,CAAC;SACX,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAA;AAC5B,CAAC","sourcesContent":["/**\n * A grid's `order` lists items in slot order: slot `k` holds item `order[k]`.\n * These keep it a permutation whatever it was written as — a stale entry past\n * the count, a repeat, or nothing at all — so a child added or removed never\n * leaves a slot empty or two items in one.\n */\n\n/** `order` repaired into a permutation of `0..count-1`: its valid entries first, then the rest in item order. */\nexport function normalizeOrder(order: readonly number[] | undefined, count: number): number[] {\n  const out: number[] = []\n  const taken = new Array<boolean>(count).fill(false)\n  for (const entry of order ?? []) {\n    const item = Math.round(entry)\n    if (item >= 0 && item < count && !taken[item]) {\n      taken[item] = true\n      out.push(item)\n    }\n  }\n  for (let item = 0; item < count; item++) if (!taken[item]) out.push(item)\n  return out\n}\n\n/** For each item, the slot it sits in. */\nexport function slotOfItem(order: readonly number[]): number[] {\n  const slots = new Array<number>(order.length)\n  order.forEach((item, slot) => {\n    slots[item] = slot\n  })\n  return slots\n}\n\n/** An order written as `\"2, 0, 1\"` or as numbers. */\nexport function parseOrder(value: unknown): number[] {\n  if (Array.isArray(value)) return value.map(Number).filter(Number.isFinite)\n  if (typeof value !== \"string\") return []\n  return value\n    .split(/[\\s,]+/)\n    .filter((part) => part !== \"\")\n    .map(Number)\n    .filter(Number.isFinite)\n}\n"]}

package/dist/kit/random.d.ts

@@ -0,0 +1,7 @@
+/** A seeded generator in `[0, 1)` — mulberry32, so a shuffle is the same on every frame and every machine. */
+export declare function seededRandom(seed: number): () => number;
+/** `values` in a seeded random order. */
+export declare function shuffled<T>(values: readonly T[], seed: number): T[];
+/** A stable number for a string — a node's id, so its "random" stagger never changes between builds. */
+export declare function hashSeed(text: string): number;
+//# sourceMappingURL=random.d.ts.map

package/dist/kit/random.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"random.d.ts","sourceRoot":"","sources":["../../src/kit/random.ts"],"names":[],"mappings":"AAAA,8GAA8G;AAC9G,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,MAAM,CASvD;AAED,yCAAyC;AACzC,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC,EAAE,CAQnE;AAED,wGAAwG;AACxG,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAI7C"}

package/dist/kit/random.js

@@ -0,0 +1,29 @@
+/** A seeded generator in `[0, 1)` — mulberry32, so a shuffle is the same on every frame and every machine. */
+export function seededRandom(seed) {
+    let a = Math.floor(seed) >>> 0;
+    return () => {
+        a = (a + 0x6d2b79f5) >>> 0;
+        let t = a;
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+/** `values` in a seeded random order. */
+export function shuffled(values, seed) {
+    const out = [...values];
+    const random = seededRandom(seed);
+    for (let i = out.length - 1; i > 0; i--) {
+        const j = Math.floor(random() * (i + 1));
+        [out[i], out[j]] = [out[j], out[i]];
+    }
+    return out;
+}
+/** A stable number for a string — a node's id, so its "random" stagger never changes between builds. */
+export function hashSeed(text) {
+    let h = 2166136261;
+    for (let i = 0; i < text.length; i++)
+        h = Math.imul(h ^ text.charCodeAt(i), 16777619);
+    return h >>> 0;
+}
+//# sourceMappingURL=random.js.map

package/dist/kit/random.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"random.js","sourceRoot":"","sources":["../../src/kit/random.ts"],"names":[],"mappings":"AAAA,8GAA8G;AAC9G,MAAM,UAAU,YAAY,CAAC,IAAY;IACvC,IAAI,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;IAC9B,OAAO,GAAG,EAAE;QACV,CAAC,GAAG,CAAC,CAAC,GAAG,UAAU,CAAC,KAAK,CAAC,CAAA;QAC1B,IAAI,CAAC,GAAG,CAAC,CAAA;QACT,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAA;QACpC,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,CAAA;QACzC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,UAAU,CAAA;IAC9C,CAAC,CAAA;AACH,CAAC;AAED,yCAAyC;AACzC,MAAM,UAAU,QAAQ,CAAI,MAAoB,EAAE,IAAY;IAC5D,MAAM,GAAG,GAAG,CAAC,GAAG,MAAM,CAAC,CAAA;IACvB,MAAM,MAAM,GAAG,YAAY,CAAC,IAAI,CAAC,CAAA;IACjC,KAAK,IAAI,CAAC,GAAG,GAAG,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QACxC,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CACvC;QAAA,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,CAAA;IACtC,CAAC;IACD,OAAO,GAAG,CAAA;AACZ,CAAC;AAED,wGAAwG;AACxG,MAAM,UAAU,QAAQ,CAAC,IAAY;IACnC,IAAI,CAAC,GAAG,UAAU,CAAA;IAClB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE;QAAE,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAA;IACrF,OAAO,CAAC,KAAK,CAAC,CAAA;AAChB,CAAC","sourcesContent":["/** A seeded generator in `[0, 1)` — mulberry32, so a shuffle is the same on every frame and every machine. */\nexport function seededRandom(seed: number): () => number {\n  let a = Math.floor(seed) >>> 0\n  return () => {\n    a = (a + 0x6d2b79f5) >>> 0\n    let t = a\n    t = Math.imul(t ^ (t >>> 15), t | 1)\n    t ^= t + Math.imul(t ^ (t >>> 7), t | 61)\n    return ((t ^ (t >>> 14)) >>> 0) / 4294967296\n  }\n}\n\n/** `values` in a seeded random order. */\nexport function shuffled<T>(values: readonly T[], seed: number): T[] {\n  const out = [...values]\n  const random = seededRandom(seed)\n  for (let i = out.length - 1; i > 0; i--) {\n    const j = Math.floor(random() * (i + 1))\n    ;[out[i], out[j]] = [out[j], out[i]]\n  }\n  return out\n}\n\n/** A stable number for a string — a node's id, so its \"random\" stagger never changes between builds. */\nexport function hashSeed(text: string): number {\n  let h = 2166136261\n  for (let i = 0; i < text.length; i++) h = Math.imul(h ^ text.charCodeAt(i), 16777619)\n  return h >>> 0\n}\n"]}

package/dist/kit/slots/index.d.ts

@@ -0,0 +1,22 @@
+import { type PathArrangement } from "./path.js";
+import { type RadialArrangement } from "./radial.js";
+import { type RectangularArrangement } from "./rectangular.js";
+import type { Slot, SlotInput } from "./slot.js";
+import { type SphereArrangement } from "./sphere.js";
+export * from "./slot.js";
+export * from "./rectangular.js";
+export * from "./radial.js";
+export * from "./path.js";
+export * from "./path-templates.js";
+export * from "./sphere.js";
+/**
+ * Everything an arrangement needs to place items, as plain data — so a
+ * transition can keep the one it is leaving, and a grid can borrow another's.
+ */
+export type Arrangement = RectangularArrangement | RadialArrangement | PathArrangement | SphereArrangement;
+export type ArrangementKind = Arrangement["kind"];
+/** Where each of `input.count` items sits under `arrangement`, in slot order. */
+export declare function slotsOf(arrangement: Arrangement, input: SlotInput): Slot[];
+/** The camera distance an arrangement is seen through, or `0` when it is flat. */
+export declare function focalLengthOf(arrangement: Arrangement): number;
+//# sourceMappingURL=index.d.ts.map

package/dist/kit/slots/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/kit/slots/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,KAAK,eAAe,EAAE,MAAM,QAAQ,CAAA;AACxD,OAAO,EAAe,KAAK,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAC9D,OAAO,EAAoB,KAAK,sBAAsB,EAAE,MAAM,eAAe,CAAA;AAC7E,OAAO,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAA;AAC7C,OAAO,EAAe,KAAK,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAE9D,cAAc,QAAQ,CAAA;AACtB,cAAc,eAAe,CAAA;AAC7B,cAAc,UAAU,CAAA;AACxB,cAAc,QAAQ,CAAA;AACtB,cAAc,kBAAkB,CAAA;AAChC,cAAc,UAAU,CAAA;AAExB;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG,sBAAsB,GAAG,iBAAiB,GAAG,eAAe,GAAG,iBAAiB,CAAA;AAE1G,MAAM,MAAM,eAAe,GAAG,WAAW,CAAC,MAAM,CAAC,CAAA;AAEjD,iFAAiF;AACjF,wBAAgB,OAAO,CAAC,WAAW,EAAE,WAAW,EAAE,KAAK,EAAE,SAAS,GAAG,IAAI,EAAE,CAW1E;AAED,kFAAkF;AAClF,wBAAgB,aAAa,CAAC,WAAW,EAAE,WAAW,GAAG,MAAM,CAE9D"}

package/dist/kit/slots/index.js

@@ -0,0 +1,28 @@
+import { pathSlots } from "./path.js";
+import { radialSlots } from "./radial.js";
+import { rectangularSlots } from "./rectangular.js";
+import { sphereSlots } from "./sphere.js";
+export * from "./slot.js";
+export * from "./rectangular.js";
+export * from "./radial.js";
+export * from "./path.js";
+export * from "./path-templates.js";
+export * from "./sphere.js";
+/** Where each of `input.count` items sits under `arrangement`, in slot order. */
+export function slotsOf(arrangement, input) {
+    switch (arrangement.kind) {
+        case "rectangular":
+            return rectangularSlots(arrangement, input);
+        case "radial":
+            return radialSlots(arrangement, input);
+        case "path":
+            return pathSlots(arrangement, input);
+        case "sphere":
+            return sphereSlots(arrangement, input);
+    }
+}
+/** The camera distance an arrangement is seen through, or `0` when it is flat. */
+export function focalLengthOf(arrangement) {
+    return arrangement.kind === "sphere" ? Math.max(1, arrangement.focalLength) : 0;
+}
+//# sourceMappingURL=index.js.map

package/dist/kit/slots/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/kit/slots/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAwB,MAAM,QAAQ,CAAA;AACxD,OAAO,EAAE,WAAW,EAA0B,MAAM,UAAU,CAAA;AAC9D,OAAO,EAAE,gBAAgB,EAA+B,MAAM,eAAe,CAAA;AAE7E,OAAO,EAAE,WAAW,EAA0B,MAAM,UAAU,CAAA;AAE9D,cAAc,QAAQ,CAAA;AACtB,cAAc,eAAe,CAAA;AAC7B,cAAc,UAAU,CAAA;AACxB,cAAc,QAAQ,CAAA;AACtB,cAAc,kBAAkB,CAAA;AAChC,cAAc,UAAU,CAAA;AAUxB,iFAAiF;AACjF,MAAM,UAAU,OAAO,CAAC,WAAwB,EAAE,KAAgB;IAChE,QAAQ,WAAW,CAAC,IAAI,EAAE,CAAC;QACzB,KAAK,aAAa;YAChB,OAAO,gBAAgB,CAAC,WAAW,EAAE,KAAK,CAAC,CAAA;QAC7C,KAAK,QAAQ;YACX,OAAO,WAAW,CAAC,WAAW,EAAE,KAAK,CAAC,CAAA;QACxC,KAAK,MAAM;YACT,OAAO,SAAS,CAAC,WAAW,EAAE,KAAK,CAAC,CAAA;QACtC,KAAK,QAAQ;YACX,OAAO,WAAW,CAAC,WAAW,EAAE,KAAK,CAAC,CAAA;IAC1C,CAAC;AACH,CAAC;AAED,kFAAkF;AAClF,MAAM,UAAU,aAAa,CAAC,WAAwB;IACpD,OAAO,WAAW,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,WAAW,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;AACjF,CAAC","sourcesContent":["import { pathSlots, type PathArrangement } from \"./path\"\nimport { radialSlots, type RadialArrangement } from \"./radial\"\nimport { rectangularSlots, type RectangularArrangement } from \"./rectangular\"\nimport type { Slot, SlotInput } from \"./slot\"\nimport { sphereSlots, type SphereArrangement } from \"./sphere\"\n\nexport * from \"./slot\"\nexport * from \"./rectangular\"\nexport * from \"./radial\"\nexport * from \"./path\"\nexport * from \"./path-templates\"\nexport * from \"./sphere\"\n\n/**\n * Everything an arrangement needs to place items, as plain data — so a\n * transition can keep the one it is leaving, and a grid can borrow another's.\n */\nexport type Arrangement = RectangularArrangement | RadialArrangement | PathArrangement | SphereArrangement\n\nexport type ArrangementKind = Arrangement[\"kind\"]\n\n/** Where each of `input.count` items sits under `arrangement`, in slot order. */\nexport function slotsOf(arrangement: Arrangement, input: SlotInput): Slot[] {\n  switch (arrangement.kind) {\n    case \"rectangular\":\n      return rectangularSlots(arrangement, input)\n    case \"radial\":\n      return radialSlots(arrangement, input)\n    case \"path\":\n      return pathSlots(arrangement, input)\n    case \"sphere\":\n      return sphereSlots(arrangement, input)\n  }\n}\n\n/** The camera distance an arrangement is seen through, or `0` when it is flat. */\nexport function focalLengthOf(arrangement: Arrangement): number {\n  return arrangement.kind === \"sphere\" ? Math.max(1, arrangement.focalLength) : 0\n}\n"]}

package/dist/kit/slots/path-templates.d.ts

@@ -0,0 +1,15 @@
+import type { PathCommand, Size2D } from "@motionscript/sdk";
+/**
+ * The shapes a path grid can follow without a path of its own, each drawn to
+ * fill the grid's box. Centred and y-up, like every path in the library; the
+ * closed ones run clockwise, so an item flowing along any of them travels the
+ * same way round.
+ */
+export declare const PATH_TEMPLATES: readonly ["circle", "square", "star", "heart", "infinity", "wave", "spiral", "arc", "line"];
+export type PathTemplate = (typeof PATH_TEMPLATES)[number];
+/**
+ * `template` drawn to fill `box`. The same template at the same size is the
+ * same array, which is what lets the path's measurement be kept between frames.
+ */
+export declare function templatePath(template: PathTemplate, box: Size2D): PathCommand[];
+//# sourceMappingURL=path-templates.d.ts.map

package/dist/kit/slots/path-templates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-templates.d.ts","sourceRoot":"","sources":["../../../src/kit/slots/path-templates.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAE5D;;;;;GAKG;AACH,eAAO,MAAM,cAAc,6FAUjB,CAAA;AACV,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,CAAC,CAAA;AAQ1D;;;GAGG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,YAAY,EAAE,GAAG,EAAE,MAAM,GAAG,WAAW,EAAE,CAQ/E"}

package/dist/kit/slots/path-templates.js

@@ -0,0 +1,113 @@
+/**
+ * The shapes a path grid can follow without a path of its own, each drawn to
+ * fill the grid's box. Centred and y-up, like every path in the library; the
+ * closed ones run clockwise, so an item flowing along any of them travels the
+ * same way round.
+ */
+export const PATH_TEMPLATES = [
+    "circle",
+    "square",
+    "star",
+    "heart",
+    "infinity",
+    "wave",
+    "spiral",
+    "arc",
+    "line",
+];
+/** What a template is drawn at when the grid has no box to fill. */
+const FALLBACK = 400;
+const DRAWN = new Map();
+const DRAWN_CACHE = 64;
+/**
+ * `template` drawn to fill `box`. The same template at the same size is the
+ * same array, which is what lets the path's measurement be kept between frames.
+ */
+export function templatePath(template, box) {
+    const key = `${template}:${Math.round(box.width * 100)}:${Math.round(box.height * 100)}`;
+    const hit = DRAWN.get(key);
+    if (hit)
+        return hit;
+    const path = drawTemplate(template, box);
+    if (DRAWN.size >= DRAWN_CACHE)
+        DRAWN.delete(DRAWN.keys().next().value);
+    DRAWN.set(key, path);
+    return path;
+}
+function drawTemplate(template, box) {
+    const w = box.width > 0 ? box.width : FALLBACK;
+    const h = box.height > 0 ? box.height : FALLBACK;
+    const rx = w / 2;
+    const ry = h / 2;
+    switch (template) {
+        case "square":
+            return closed([
+                [-rx, ry], [rx, ry], [rx, -ry], [-rx, -ry],
+            ]);
+        case "star": {
+            const points = [];
+            for (let i = 0; i < 10; i++) {
+                const angle = (i * Math.PI) / 5;
+                const r = i % 2 === 0 ? 1 : 0.45;
+                points.push([Math.sin(angle) * rx * r, Math.cos(angle) * ry * r]);
+            }
+            return closed(points);
+        }
+        case "heart":
+            return closed(sample(96, (t) => {
+                // The classic heart curve, from its top notch, clockwise.
+                const a = t * 2 * Math.PI;
+                const x = 16 * Math.sin(a) ** 3;
+                const y = 13 * Math.cos(a) - 5 * Math.cos(2 * a) - 2 * Math.cos(3 * a) - Math.cos(4 * a);
+                return [(x / 17) * rx, ((y + 2.5) / 15.5) * ry];
+            }).slice(0, -1));
+        case "infinity":
+            return closed(sample(96, (t) => {
+                const a = t * 2 * Math.PI;
+                const d = 1 + Math.sin(a) ** 2;
+                return [(Math.cos(a) / d) * rx, ((Math.sin(a) * Math.cos(a)) / d) * ry * 2];
+            }).slice(0, -1));
+        case "wave":
+            return open(sample(96, (t) => [(-1 + 2 * t) * rx, Math.sin(t * 4 * Math.PI) * ry * 0.6]));
+        case "spiral":
+            return open(sample(160, (t) => {
+                const a = t * 3 * 2 * Math.PI;
+                const r = 0.08 + 0.92 * t;
+                return [Math.sin(a) * rx * r, Math.cos(a) * ry * r];
+            }));
+        case "arc":
+            return open(sample(64, (t) => {
+                const a = -Math.PI / 2 + t * Math.PI;
+                return [Math.sin(a) * rx, -ry + Math.cos(a) * h];
+            }));
+        case "line":
+            return [{ type: "M", x: -rx, y: 0 }, { type: "L", x: rx, y: 0 }];
+        default:
+            return ellipse(rx, ry);
+    }
+}
+/** Four quarter-arcs from the top, clockwise. */
+function ellipse(rx, ry) {
+    const k = 0.5522847498;
+    return [
+        { type: "M", x: 0, y: ry },
+        { type: "C", x1: k * rx, y1: ry, x2: rx, y2: k * ry, x: rx, y: 0 },
+        { type: "C", x1: rx, y1: -k * ry, x2: k * rx, y2: -ry, x: 0, y: -ry },
+        { type: "C", x1: -k * rx, y1: -ry, x2: -rx, y2: -k * ry, x: -rx, y: 0 },
+        { type: "C", x1: -rx, y1: k * ry, x2: -k * rx, y2: ry, x: 0, y: ry },
+        { type: "Z" },
+    ];
+}
+function sample(steps, at) {
+    const points = [];
+    for (let i = 0; i <= steps; i++)
+        points.push(at(i / steps));
+    return points;
+}
+function open(points) {
+    return points.map(([x, y], i) => (i === 0 ? { type: "M", x, y } : { type: "L", x, y }));
+}
+function closed(points) {
+    return [...open(points), { type: "Z" }];
+}
+//# sourceMappingURL=path-templates.js.map

package/dist/kit/slots/path-templates.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-templates.js","sourceRoot":"","sources":["../../../src/kit/slots/path-templates.ts"],"names":[],"mappings":"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","sourcesContent":["import type { PathCommand, Size2D } from \"@motionscript/sdk\"\n\n/**\n * The shapes a path grid can follow without a path of its own, each drawn to\n * fill the grid's box. Centred and y-up, like every path in the library; the\n * closed ones run clockwise, so an item flowing along any of them travels the\n * same way round.\n */\nexport const PATH_TEMPLATES = [\n  \"circle\",\n  \"square\",\n  \"star\",\n  \"heart\",\n  \"infinity\",\n  \"wave\",\n  \"spiral\",\n  \"arc\",\n  \"line\",\n] as const\nexport type PathTemplate = (typeof PATH_TEMPLATES)[number]\n\n/** What a template is drawn at when the grid has no box to fill. */\nconst FALLBACK = 400\n\nconst DRAWN = new Map<string, PathCommand[]>()\nconst DRAWN_CACHE = 64\n\n/**\n * `template` drawn to fill `box`. The same template at the same size is the\n * same array, which is what lets the path's measurement be kept between frames.\n */\nexport function templatePath(template: PathTemplate, box: Size2D): PathCommand[] {\n  const key = `${template}:${Math.round(box.width * 100)}:${Math.round(box.height * 100)}`\n  const hit = DRAWN.get(key)\n  if (hit) return hit\n  const path = drawTemplate(template, box)\n  if (DRAWN.size >= DRAWN_CACHE) DRAWN.delete(DRAWN.keys().next().value!)\n  DRAWN.set(key, path)\n  return path\n}\n\nfunction drawTemplate(template: PathTemplate, box: Size2D): PathCommand[] {\n  const w = box.width > 0 ? box.width : FALLBACK\n  const h = box.height > 0 ? box.height : FALLBACK\n  const rx = w / 2\n  const ry = h / 2\n  switch (template) {\n    case \"square\":\n      return closed([\n        [-rx, ry], [rx, ry], [rx, -ry], [-rx, -ry],\n      ])\n    case \"star\": {\n      const points: [number, number][] = []\n      for (let i = 0; i < 10; i++) {\n        const angle = (i * Math.PI) / 5\n        const r = i % 2 === 0 ? 1 : 0.45\n        points.push([Math.sin(angle) * rx * r, Math.cos(angle) * ry * r])\n      }\n      return closed(points)\n    }\n    case \"heart\":\n      return closed(sample(96, (t) => {\n        // The classic heart curve, from its top notch, clockwise.\n        const a = t * 2 * Math.PI\n        const x = 16 * Math.sin(a) ** 3\n        const y = 13 * Math.cos(a) - 5 * Math.cos(2 * a) - 2 * Math.cos(3 * a) - Math.cos(4 * a)\n        return [(x / 17) * rx, ((y + 2.5) / 15.5) * ry]\n      }).slice(0, -1))\n    case \"infinity\":\n      return closed(sample(96, (t) => {\n        const a = t * 2 * Math.PI\n        const d = 1 + Math.sin(a) ** 2\n        return [(Math.cos(a) / d) * rx, ((Math.sin(a) * Math.cos(a)) / d) * ry * 2]\n      }).slice(0, -1))\n    case \"wave\":\n      return open(sample(96, (t) => [(-1 + 2 * t) * rx, Math.sin(t * 4 * Math.PI) * ry * 0.6]))\n    case \"spiral\":\n      return open(sample(160, (t) => {\n        const a = t * 3 * 2 * Math.PI\n        const r = 0.08 + 0.92 * t\n        return [Math.sin(a) * rx * r, Math.cos(a) * ry * r]\n      }))\n    case \"arc\":\n      return open(sample(64, (t) => {\n        const a = -Math.PI / 2 + t * Math.PI\n        return [Math.sin(a) * rx, -ry + Math.cos(a) * h]\n      }))\n    case \"line\":\n      return [{ type: \"M\", x: -rx, y: 0 }, { type: \"L\", x: rx, y: 0 }]\n    default:\n      return ellipse(rx, ry)\n  }\n}\n\n/** Four quarter-arcs from the top, clockwise. */\nfunction ellipse(rx: number, ry: number): PathCommand[] {\n  const k = 0.5522847498\n  return [\n    { type: \"M\", x: 0, y: ry },\n    { type: \"C\", x1: k * rx, y1: ry, x2: rx, y2: k * ry, x: rx, y: 0 },\n    { type: \"C\", x1: rx, y1: -k * ry, x2: k * rx, y2: -ry, x: 0, y: -ry },\n    { type: \"C\", x1: -k * rx, y1: -ry, x2: -rx, y2: -k * ry, x: -rx, y: 0 },\n    { type: \"C\", x1: -rx, y1: k * ry, x2: -k * rx, y2: ry, x: 0, y: ry },\n    { type: \"Z\" },\n  ]\n}\n\nfunction sample(steps: number, at: (t: number) => [number, number]): [number, number][] {\n  const points: [number, number][] = []\n  for (let i = 0; i <= steps; i++) points.push(at(i / steps))\n  return points\n}\n\nfunction open(points: [number, number][]): PathCommand[] {\n  return points.map(([x, y], i) => (i === 0 ? { type: \"M\", x, y } : { type: \"L\", x, y }))\n}\n\nfunction closed(points: [number, number][]): PathCommand[] {\n  return [...open(points), { type: \"Z\" }]\n}\n"]}

package/dist/kit/slots/path.d.ts

@@ -0,0 +1,45 @@
+import { type PathData } from "@motionscript/sdk";
+import { type Slot, type SlotInput } from "./slot.js";
+/** `distribute` spreads the items over the path; `fixed` sets them a distance apart. */
+export declare const PATH_SPACINGS: readonly ["distribute", "fixed"];
+export type PathSpacing = (typeof PATH_SPACINGS)[number];
+/** How path coordinates land in the grid's frame: `origin` of the path goes to `(x, y)`, turned and scaled. */
+export interface PathPlacement {
+    originX: number;
+    originY: number;
+    /** The path is y-down, as SVG and the editor write one. */
+    flipY?: boolean;
+    x: number;
+    y: number;
+    /** Degrees clockwise. */
+    rotation: number;
+    scale: number;
+}
+export interface PathArrangement {
+    kind: "path";
+    /** y-up, like every path in the library, unless its placement says otherwise. */
+    path: PathData;
+    placement: PathPlacement;
+    spacing: PathSpacing;
+    /** Pixels between items when `spacing` is `fixed`. */
+    spacingDistance: number;
+    /** Share of the path the items are moved along; wraps on a closed path. */
+    offset: number;
+    /** Share of the path per second the items travel on their own. */
+    flowSpeed: number;
+    trimStart: number;
+    trimEnd: number;
+    /** Turn each item to follow the path's direction. */
+    alignToPath: boolean;
+}
+/**
+ * Items at even arc-length steps — by distance along the curve rather than the
+ * path's own parameter, which bunches them up wherever a curve is tight.
+ *
+ * On a closed path used whole, `n` items take `n` equal steps and `offset`
+ * wraps round, so an animated offset is a loop. Anywhere else the ends are
+ * ends: `n` items take `n - 1` steps so both get one, and an item moved past
+ * either is hidden rather than piled on it.
+ */
+export declare function pathSlots(arrangement: PathArrangement, input: SlotInput): Slot[];
+//# sourceMappingURL=path.d.ts.map

package/dist/kit/slots/path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path.d.ts","sourceRoot":"","sources":["../../../src/kit/slots/path.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,KAAK,QAAQ,EAAoB,MAAM,mBAAmB,CAAA;AAE5E,OAAO,EAAQ,KAAK,IAAI,EAAE,KAAK,SAAS,EAAE,MAAM,QAAQ,CAAA;AAExD,wFAAwF;AACxF,eAAO,MAAM,aAAa,kCAAmC,CAAA;AAC7D,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,CAAC,CAAA;AAExD,+GAA+G;AAC/G,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;IACf,2DAA2D;IAC3D,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,yBAAyB;IACzB,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,MAAM,CAAA;CACd;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAA;IACZ,iFAAiF;IACjF,IAAI,EAAE,QAAQ,CAAA;IACd,SAAS,EAAE,aAAa,CAAA;IACxB,OAAO,EAAE,WAAW,CAAA;IACpB,sDAAsD;IACtD,eAAe,EAAE,MAAM,CAAA;IACvB,2EAA2E;IAC3E,MAAM,EAAE,MAAM,CAAA;IACd,kEAAkE;IAClE,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,MAAM,CAAA;IACf,qDAAqD;IACrD,WAAW,EAAE,OAAO,CAAA;CACrB;AAmBD;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,WAAW,EAAE,eAAe,EAAE,KAAK,EAAE,SAAS,GAAG,IAAI,EAAE,CAkDhF"}

package/dist/kit/slots/path.js

@@ -0,0 +1,87 @@
+import { pathOps } from "@motionscript/sdk";
+import { slot } from "./slot.js";
+/** `distribute` spreads the items over the path; `fixed` sets them a distance apart. */
+export const PATH_SPACINGS = ["distribute", "fixed"];
+const SAMPLERS = new Map();
+const SAMPLER_CACHE = 32;
+/** A sampler for `path`, kept while the same value keeps arriving — a path is re-read every frame. */
+function measured(path) {
+    const hit = SAMPLERS.get(path);
+    if (hit)
+        return hit;
+    const contours = pathOps.contours(path);
+    const entry = {
+        sampler: pathOps.sampler(path),
+        closed: contours.length === 1 && contours[0].closed,
+    };
+    if (SAMPLERS.size >= SAMPLER_CACHE)
+        SAMPLERS.delete(SAMPLERS.keys().next().value);
+    SAMPLERS.set(path, entry);
+    return entry;
+}
+/**
+ * Items at even arc-length steps — by distance along the curve rather than the
+ * path's own parameter, which bunches them up wherever a curve is tight.
+ *
+ * On a closed path used whole, `n` items take `n` equal steps and `offset`
+ * wraps round, so an animated offset is a loop. Anywhere else the ends are
+ * ends: `n` items take `n - 1` steps so both get one, and an item moved past
+ * either is hidden rather than piled on it.
+ */
+export function pathSlots(arrangement, input) {
+    const { count } = input;
+    if (count === 0)
+        return [];
+    const { sampler, closed } = measured(arrangement.path);
+    const length = sampler.length;
+    const a = clamp01(Math.min(arrangement.trimStart, arrangement.trimEnd));
+    const b = clamp01(Math.max(arrangement.trimStart, arrangement.trimEnd));
+    const start = a * length;
+    const span = (b - a) * length;
+    const loops = closed && a === 0 && b === 1;
+    const offset = arrangement.offset + arrangement.flowSpeed * input.time;
+    const place = arrangement.placement;
+    const rad = (place.rotation * Math.PI) / 180;
+    const cos = Math.cos(rad);
+    const sin = Math.sin(rad);
+    const slots = [];
+    for (let k = 0; k < count; k++) {
+        let u;
+        if (arrangement.spacing === "fixed" && span > 0) {
+            u = offset + (k * arrangement.spacingDistance) / span;
+        }
+        else if (loops) {
+            u = offset + k / count;
+        }
+        else {
+            u = offset + (count === 1 ? 0.5 : k / (count - 1));
+        }
+        let visible = true;
+        if (loops)
+            u = u - Math.floor(u);
+        else if (u < -1e-9 || u > 1 + 1e-9)
+            visible = false;
+        const at = sampler.frameAt(start + clamp01(u) * span);
+        if (!at) {
+            const s = slot(0, 0, { kind: "path", t: clamp01(u) });
+            s.opacity = 0;
+            slots.push(s);
+            continue;
+        }
+        // Into the grid's frame: about the path's origin, turned clockwise (y-up).
+        const flip = place.flipY ? -1 : 1;
+        const px = (at.x - place.originX) * place.scale;
+        const py = (at.y - place.originY) * place.scale * flip;
+        const s = slot(place.x + px * cos + py * sin, place.y - px * sin + py * cos, { kind: "path", t: clamp01(u) });
+        if (arrangement.alignToPath)
+            s.rotation = (-Math.atan2(at.ty * flip, at.tx) * 180) / Math.PI + place.rotation;
+        if (!visible)
+            s.opacity = 0;
+        slots.push(s);
+    }
+    return slots;
+}
+function clamp01(v) {
+    return v < 0 ? 0 : v > 1 ? 1 : v;
+}
+//# sourceMappingURL=path.js.map

package/dist/kit/slots/path.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"path.js","sourceRoot":"","sources":["../../../src/kit/slots/path.ts"],"names":[],"mappings":"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","sourcesContent":["import { pathOps, type PathData, type PathSampler } from \"@motionscript/sdk\"\n\nimport { slot, type Slot, type SlotInput } from \"./slot\"\n\n/** `distribute` spreads the items over the path; `fixed` sets them a distance apart. */\nexport const PATH_SPACINGS = [\"distribute\", \"fixed\"] as const\nexport type PathSpacing = (typeof PATH_SPACINGS)[number]\n\n/** How path coordinates land in the grid's frame: `origin` of the path goes to `(x, y)`, turned and scaled. */\nexport interface PathPlacement {\n  originX: number\n  originY: number\n  /** The path is y-down, as SVG and the editor write one. */\n  flipY?: boolean\n  x: number\n  y: number\n  /** Degrees clockwise. */\n  rotation: number\n  scale: number\n}\n\nexport interface PathArrangement {\n  kind: \"path\"\n  /** y-up, like every path in the library, unless its placement says otherwise. */\n  path: PathData\n  placement: PathPlacement\n  spacing: PathSpacing\n  /** Pixels between items when `spacing` is `fixed`. */\n  spacingDistance: number\n  /** Share of the path the items are moved along; wraps on a closed path. */\n  offset: number\n  /** Share of the path per second the items travel on their own. */\n  flowSpeed: number\n  trimStart: number\n  trimEnd: number\n  /** Turn each item to follow the path's direction. */\n  alignToPath: boolean\n}\n\nconst SAMPLERS = new Map<PathData, { sampler: PathSampler; closed: boolean }>()\nconst SAMPLER_CACHE = 32\n\n/** A sampler for `path`, kept while the same value keeps arriving — a path is re-read every frame. */\nfunction measured(path: PathData): { sampler: PathSampler; closed: boolean } {\n  const hit = SAMPLERS.get(path)\n  if (hit) return hit\n  const contours = pathOps.contours(path)\n  const entry = {\n    sampler: pathOps.sampler(path),\n    closed: contours.length === 1 && contours[0].closed,\n  }\n  if (SAMPLERS.size >= SAMPLER_CACHE) SAMPLERS.delete(SAMPLERS.keys().next().value!)\n  SAMPLERS.set(path, entry)\n  return entry\n}\n\n/**\n * Items at even arc-length steps — by distance along the curve rather than the\n * path's own parameter, which bunches them up wherever a curve is tight.\n *\n * On a closed path used whole, `n` items take `n` equal steps and `offset`\n * wraps round, so an animated offset is a loop. Anywhere else the ends are\n * ends: `n` items take `n - 1` steps so both get one, and an item moved past\n * either is hidden rather than piled on it.\n */\nexport function pathSlots(arrangement: PathArrangement, input: SlotInput): Slot[] {\n  const { count } = input\n  if (count === 0) return []\n  const { sampler, closed } = measured(arrangement.path)\n  const length = sampler.length\n  const a = clamp01(Math.min(arrangement.trimStart, arrangement.trimEnd))\n  const b = clamp01(Math.max(arrangement.trimStart, arrangement.trimEnd))\n  const start = a * length\n  const span = (b - a) * length\n  const loops = closed && a === 0 && b === 1\n  const offset = arrangement.offset + arrangement.flowSpeed * input.time\n  const place = arrangement.placement\n  const rad = (place.rotation * Math.PI) / 180\n  const cos = Math.cos(rad)\n  const sin = Math.sin(rad)\n\n  const slots: Slot[] = []\n  for (let k = 0; k < count; k++) {\n    let u: number\n    if (arrangement.spacing === \"fixed\" && span > 0) {\n      u = offset + (k * arrangement.spacingDistance) / span\n    } else if (loops) {\n      u = offset + k / count\n    } else {\n      u = offset + (count === 1 ? 0.5 : k / (count - 1))\n    }\n    let visible = true\n    if (loops) u = u - Math.floor(u)\n    else if (u < -1e-9 || u > 1 + 1e-9) visible = false\n    const at = sampler.frameAt(start + clamp01(u) * span)\n    if (!at) {\n      const s = slot(0, 0, { kind: \"path\", t: clamp01(u) })\n      s.opacity = 0\n      slots.push(s)\n      continue\n    }\n    // Into the grid's frame: about the path's origin, turned clockwise (y-up).\n    const flip = place.flipY ? -1 : 1\n    const px = (at.x - place.originX) * place.scale\n    const py = (at.y - place.originY) * place.scale * flip\n    const s = slot(\n      place.x + px * cos + py * sin,\n      place.y - px * sin + py * cos,\n      { kind: \"path\", t: clamp01(u) },\n    )\n    if (arrangement.alignToPath) s.rotation = (-Math.atan2(at.ty * flip, at.tx) * 180) / Math.PI + place.rotation\n    if (!visible) s.opacity = 0\n    slots.push(s)\n  }\n  return slots\n}\n\nfunction clamp01(v: number): number {\n  return v < 0 ? 0 : v > 1 ? 1 : v\n}\n"]}

package/dist/kit/slots/radial.d.ts

@@ -0,0 +1,30 @@
+import { type Slot, type SlotInput } from "./slot.js";
+export declare const RADIAL_DIRECTIONS: readonly ["clockwise", "counterclockwise"];
+export type RadialDirection = (typeof RADIAL_DIRECTIONS)[number];
+export interface RadialArrangement {
+    kind: "radial";
+    radius: number;
+    /** Where the first item sits, degrees clockwise from twelve o'clock. */
+    startAngle: number;
+    /** How much of the circle the items span, degrees. */
+    sweep: number;
+    direction: RadialDirection;
+    /** Turn each item so its top faces away from the centre. */
+    rotateItems: boolean;
+    /** Degrees per second the ring turns on its own. */
+    spinSpeed: number;
+}
+/**
+ * The angle of each of `count` slots, clockwise from twelve o'clock. A full
+ * circle divides by the count, so the last item does not land on the first; an
+ * arc divides by one less, so both ends get an item. In between the divisor
+ * slides from one to the other as the arc closes — steeply, so an arc is an arc
+ * until it is nearly whole, and a sweep animated to 360 lands without a jump.
+ */
+export declare function radialAngles(arrangement: RadialArrangement, count: number, time: number): number[];
+export declare function radialSlots(arrangement: RadialArrangement, input: SlotInput): Slot[];
+/** The change to `startAngle` that brings slot `index` to twelve o'clock by the shorter way round. */
+export declare function radialTurnToTop(arrangement: RadialArrangement, count: number, index: number): number;
+/** `degrees` folded into `(-180, 180]`. */
+export declare function wrapDegrees(degrees: number): number;
+//# sourceMappingURL=radial.d.ts.map

package/dist/kit/slots/radial.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"radial.d.ts","sourceRoot":"","sources":["../../../src/kit/slots/radial.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,IAAI,EAAE,KAAK,SAAS,EAAE,MAAM,QAAQ,CAAA;AAExD,eAAO,MAAM,iBAAiB,4CAA6C,CAAA;AAC3E,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAA;AAEhE,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,QAAQ,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,wEAAwE;IACxE,UAAU,EAAE,MAAM,CAAA;IAClB,sDAAsD;IACtD,KAAK,EAAE,MAAM,CAAA;IACb,SAAS,EAAE,eAAe,CAAA;IAC1B,4DAA4D;IAC5D,WAAW,EAAE,OAAO,CAAA;IACpB,oDAAoD;IACpD,SAAS,EAAE,MAAM,CAAA;CAClB;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,WAAW,EAAE,iBAAiB,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CASlG;AAED,wBAAgB,WAAW,CAAC,WAAW,EAAE,iBAAiB,EAAE,KAAK,EAAE,SAAS,GAAG,IAAI,EAAE,CAYpF;AAED,sGAAsG;AACtG,wBAAgB,eAAe,CAAC,WAAW,EAAE,iBAAiB,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAGpG;AAED,2CAA2C;AAC3C,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAGnD"}

package/dist/kit/slots/radial.js

@@ -0,0 +1,45 @@
+import { slot } from "./slot.js";
+export const RADIAL_DIRECTIONS = ["clockwise", "counterclockwise"];
+/**
+ * The angle of each of `count` slots, clockwise from twelve o'clock. A full
+ * circle divides by the count, so the last item does not land on the first; an
+ * arc divides by one less, so both ends get an item. In between the divisor
+ * slides from one to the other as the arc closes — steeply, so an arc is an arc
+ * until it is nearly whole, and a sweep animated to 360 lands without a jump.
+ */
+export function radialAngles(arrangement, count, time) {
+    const sweep = arrangement.sweep;
+    const closing = Math.min(1, Math.abs(sweep) / 360) ** 8;
+    const step = count <= 1 ? 0 : sweep / (count - 1 + closing);
+    const sign = arrangement.direction === "counterclockwise" ? -1 : 1;
+    const start = arrangement.startAngle + arrangement.spinSpeed * time;
+    const angles = [];
+    for (let k = 0; k < count; k++)
+        angles.push(start + sign * k * step);
+    return angles;
+}
+export function radialSlots(arrangement, input) {
+    const angles = radialAngles(arrangement, input.count, input.time);
+    const start = angles[0] ?? 0;
+    return angles.map((angle) => {
+        const rad = (angle * Math.PI) / 180;
+        const s = slot(arrangement.radius * Math.sin(rad), arrangement.radius * Math.cos(rad), {
+            kind: "radial",
+            angle: Math.abs(angle - start),
+        });
+        if (arrangement.rotateItems)
+            s.rotation = angle;
+        return s;
+    });
+}
+/** The change to `startAngle` that brings slot `index` to twelve o'clock by the shorter way round. */
+export function radialTurnToTop(arrangement, count, index) {
+    const angle = radialAngles({ ...arrangement, spinSpeed: 0 }, count, 0)[index] ?? arrangement.startAngle;
+    return -wrapDegrees(angle);
+}
+/** `degrees` folded into `(-180, 180]`. */
+export function wrapDegrees(degrees) {
+    const wrapped = ((degrees % 360) + 360) % 360;
+    return wrapped > 180 ? wrapped - 360 : wrapped;
+}
+//# sourceMappingURL=radial.js.map

package/dist/kit/slots/radial.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"radial.js","sourceRoot":"","sources":["../../../src/kit/slots/radial.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAA6B,MAAM,QAAQ,CAAA;AAExD,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,WAAW,EAAE,kBAAkB,CAAU,CAAA;AAiB3E;;;;;;GAMG;AACH,MAAM,UAAU,YAAY,CAAC,WAA8B,EAAE,KAAa,EAAE,IAAY;IACtF,MAAM,KAAK,GAAG,WAAW,CAAC,KAAK,CAAA;IAC/B,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,IAAI,CAAC,CAAA;IACvD,MAAM,IAAI,GAAG,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,KAAK,GAAG,CAAC,GAAG,OAAO,CAAC,CAAA;IAC3D,MAAM,IAAI,GAAG,WAAW,CAAC,SAAS,KAAK,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;IAClE,MAAM,KAAK,GAAG,WAAW,CAAC,UAAU,GAAG,WAAW,CAAC,SAAS,GAAG,IAAI,CAAA;IACnE,MAAM,MAAM,GAAa,EAAE,CAAA;IAC3B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,EAAE;QAAE,MAAM,CAAC,IAAI,CAAC,KAAK,GAAG,IAAI,GAAG,CAAC,GAAG,IAAI,CAAC,CAAA;IACpE,OAAO,MAAM,CAAA;AACf,CAAC;AAED,MAAM,UAAU,WAAW,CAAC,WAA8B,EAAE,KAAgB;IAC1E,MAAM,MAAM,GAAG,YAAY,CAAC,WAAW,EAAE,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,CAAA;IACjE,MAAM,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,CAAA;IAC5B,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;QAC1B,MAAM,GAAG,GAAG,CAAC,KAAK,GAAG,IAAI,CAAC,EAAE,CAAC,GAAG,GAAG,CAAA;QACnC,MAAM,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,WAAW,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;YACrF,IAAI,EAAE,QAAQ;YACd,KAAK,EAAE,IAAI,CAAC,GAAG,CAAC,KAAK,GAAG,KAAK,CAAC;SAC/B,CAAC,CAAA;QACF,IAAI,WAAW,CAAC,WAAW;YAAE,CAAC,CAAC,QAAQ,GAAG,KAAK,CAAA;QAC/C,OAAO,CAAC,CAAA;IACV,CAAC,CAAC,CAAA;AACJ,CAAC;AAED,sGAAsG;AACtG,MAAM,UAAU,eAAe,CAAC,WAA8B,EAAE,KAAa,EAAE,KAAa;IAC1F,MAAM,KAAK,GAAG,YAAY,CAAC,EAAE,GAAG,WAAW,EAAE,SAAS,EAAE,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,WAAW,CAAC,UAAU,CAAA;IACvG,OAAO,CAAC,WAAW,CAAC,KAAK,CAAC,CAAA;AAC5B,CAAC;AAED,2CAA2C;AAC3C,MAAM,UAAU,WAAW,CAAC,OAAe;IACzC,MAAM,OAAO,GAAG,CAAC,CAAC,OAAO,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,CAAA;IAC7C,OAAO,OAAO,GAAG,GAAG,CAAC,CAAC,CAAC,OAAO,GAAG,GAAG,CAAC,CAAC,CAAC,OAAO,CAAA;AAChD,CAAC","sourcesContent":["import { slot, type Slot, type SlotInput } from \"./slot\"\n\nexport const RADIAL_DIRECTIONS = [\"clockwise\", \"counterclockwise\"] as const\nexport type RadialDirection = (typeof RADIAL_DIRECTIONS)[number]\n\nexport interface RadialArrangement {\n  kind: \"radial\"\n  radius: number\n  /** Where the first item sits, degrees clockwise from twelve o'clock. */\n  startAngle: number\n  /** How much of the circle the items span, degrees. */\n  sweep: number\n  direction: RadialDirection\n  /** Turn each item so its top faces away from the centre. */\n  rotateItems: boolean\n  /** Degrees per second the ring turns on its own. */\n  spinSpeed: number\n}\n\n/**\n * The angle of each of `count` slots, clockwise from twelve o'clock. A full\n * circle divides by the count, so the last item does not land on the first; an\n * arc divides by one less, so both ends get an item. In between the divisor\n * slides from one to the other as the arc closes — steeply, so an arc is an arc\n * until it is nearly whole, and a sweep animated to 360 lands without a jump.\n */\nexport function radialAngles(arrangement: RadialArrangement, count: number, time: number): number[] {\n  const sweep = arrangement.sweep\n  const closing = Math.min(1, Math.abs(sweep) / 360) ** 8\n  const step = count <= 1 ? 0 : sweep / (count - 1 + closing)\n  const sign = arrangement.direction === \"counterclockwise\" ? -1 : 1\n  const start = arrangement.startAngle + arrangement.spinSpeed * time\n  const angles: number[] = []\n  for (let k = 0; k < count; k++) angles.push(start + sign * k * step)\n  return angles\n}\n\nexport function radialSlots(arrangement: RadialArrangement, input: SlotInput): Slot[] {\n  const angles = radialAngles(arrangement, input.count, input.time)\n  const start = angles[0] ?? 0\n  return angles.map((angle) => {\n    const rad = (angle * Math.PI) / 180\n    const s = slot(arrangement.radius * Math.sin(rad), arrangement.radius * Math.cos(rad), {\n      kind: \"radial\",\n      angle: Math.abs(angle - start),\n    })\n    if (arrangement.rotateItems) s.rotation = angle\n    return s\n  })\n}\n\n/** The change to `startAngle` that brings slot `index` to twelve o'clock by the shorter way round. */\nexport function radialTurnToTop(arrangement: RadialArrangement, count: number, index: number): number {\n  const angle = radialAngles({ ...arrangement, spinSpeed: 0 }, count, 0)[index] ?? arrangement.startAngle\n  return -wrapDegrees(angle)\n}\n\n/** `degrees` folded into `(-180, 180]`. */\nexport function wrapDegrees(degrees: number): number {\n  const wrapped = ((degrees % 360) + 360) % 360\n  return wrapped > 180 ? wrapped - 360 : wrapped\n}\n"]}