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

package/dist/browser/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/rectangular-grid/rectangular-grid.ts", "../../src/radial-grid/radial-grid.ts", "../../src/path-grid/path-grid.ts", "../../src/sphere-grid/sphere-grid.ts", "../../src/nodes.ts"],
+  "sourcesContent": ["import {\n  command,\n  easeInOut,\n  node,\n  property,\n  type Command,\n  type CommandArgs,\n  type NodeConfig,\n  type Size2D,\n} from \"@motionscript/core\"\n\nimport {\n  CELL_MODES,\n  contentBoxOf,\n  FILL_DIRECTIONS,\n  LINE_ALIGNS,\n  LayoutGrid,\n  rectangularCell,\n  staggerArgs,\n  TRANSITION_STAGGER,\n  type CellMode,\n  type FillDirection,\n  type LayoutGridProps,\n  type LineAlign,\n  type RectangularArrangement,\n  type StaggerArgs,\n} from \"../kit\"\n\nexport interface RectangularGridProps extends LayoutGridProps {\n  columns: number\n  fillDirection: FillDirection\n  cellMode: CellMode\n  cellWidth: number\n  cellHeight: number\n  columnGap: number\n  rowGap: number\n  lastLineAlign: LineAlign\n  rowOffset: number\n  columnOffset: number\n}\n\n/**\n * Children in rows and columns — the grid the other three are variations on.\n *\n * Cells are as big as the largest child (`fit`), a size of their own\n * (`fixed`), or an equal share of the node's box (`fill`), which is also the\n * room a child set to fill grows into. Shift every other row by half a cell\n * for a brick bond or a hex pack.\n */\n@node({\n  key: \"rectangularGrid\",\n  parentKey: \"node\",\n  forkable: true,\n  layout: {\n    children: \"grid\",\n    acceptsChildren: true,\n    defaultWidthMode: \"hug\",\n    defaultHeightMode: \"hug\",\n  },\n})\nexport class RectangularGrid extends LayoutGrid<RectangularGridProps> {\n  @property({ default: 3, min: 1, step: 1 }) declare columns: number\n  @property({ default: \"row\", kind: \"enum\", options: FILL_DIRECTIONS }) declare fillDirection: FillDirection\n  @property({ default: \"fit\", kind: \"enum\", options: CELL_MODES }) declare cellMode: CellMode\n  @property({ default: 120, min: 0, step: 1 }) declare cellWidth: number\n  @property({ default: 120, min: 0, step: 1 }) declare cellHeight: number\n  @property({ default: 24, step: 1 }) declare columnGap: number\n  @property({ default: 24, step: 1 }) declare rowGap: number\n  @property({ default: \"start\", kind: \"enum\", options: LINE_ALIGNS }) declare lastLineAlign: LineAlign\n  @property({ default: 0, min: -1, max: 1, step: 0.05 }) declare rowOffset: number\n  @property({ default: 0, min: -1, max: 1, step: 0.05 }) declare columnOffset: number\n\n  constructor(props?: NodeConfig<RectangularGrid, RectangularGridProps>) {\n    super(props)\n  }\n\n  /** Re-flow the items into `columns` columns, each moving to its new cell. */\n  @command({ args: [{ key: \"columns\", min: 1, step: 1, default: 4 }, ...staggerArgs(TRANSITION_STAGGER)] })\n  columnsTo(args: CommandArgs<{ columns: number } & StaggerArgs> & { duration: number }): Command<RectangularGridProps> {\n    const columns = Math.max(1, Math.round(args.data?.columns ?? this.columns))\n    return this._transitionTo({ columns }, args)\n  }\n\n  /** Animate the spacing between columns and rows. */\n  @command({ args: [{ key: \"columnGap\", default: 48 }, { key: \"rowGap\", default: 48 }] })\n  gapTo(args: CommandArgs<{ columnGap?: number; rowGap?: number }> & { duration: number }): Command<RectangularGridProps> {\n    const data: Partial<RectangularGridProps> = {}\n    if (args.data?.columnGap !== undefined) data.columnGap = args.data.columnGap\n    if (args.data?.rowGap !== undefined) data.rowGap = args.data.rowGap\n    return this.to({ data, duration: args.duration, easing: args.easing })\n  }\n\n  /**\n   * Animate the cell size, from whatever the cells measure now. The grid\n   * switches to `fixed` cells as it starts, since a size of its own is what\n   * `fixed` means.\n   */\n  @command({ args: [{ key: \"cellWidth\", min: 0, default: 160 }, { key: \"cellHeight\", min: 0, default: 160 }] })\n  cellSizeTo(args: CommandArgs<{ cellWidth?: number; cellHeight?: number }> & { duration: number }): Command<RectangularGridProps> {\n    const sizes = this._itemSizes()\n    const from = rectangularCell(this.arrangementFor(), sizes.length, sizes, contentBoxOf(this))\n    const width = args.data?.cellWidth ?? from.width\n    const height = args.data?.cellHeight ?? from.height\n    return this.command<RectangularGridProps>((t) => ({\n      cellMode: \"fixed\",\n      cellWidth: from.width + (width - from.width) * t,\n      cellHeight: from.height + (height - from.height) * t,\n    }), args.duration, args.easing ?? easeInOut(\"cubic\"))\n  }\n\n  /** Bring one row (from 0 at the top) forward and push the rest back. */\n  @command({\n    args: [\n      { key: \"row\", min: 0, step: 1, default: 0 },\n      { key: \"dim\", min: 0, max: 1, step: 0.05, default: 0.7 },\n      { key: \"grow\", min: 0, max: 1, step: 0.05, default: 0.1 },\n    ],\n  })\n  focusRow(args: CommandArgs<{ row?: number; dim?: number; grow?: number }> & { duration: number }): Command<LayoutGridProps> {\n    const slots = this._itemSlots()\n    const row = Math.round(args.data?.row ?? 0)\n    return this._focusOn((i) => slots[i]?.meta.kind === \"rectangular\" && slots[i].meta.row === row, slots.length, args)\n  }\n\n  /** Bring one column (from 0 at the left) forward and push the rest back. */\n  @command({\n    args: [\n      { key: \"column\", min: 0, step: 1, default: 0 },\n      { key: \"dim\", min: 0, max: 1, step: 0.05, default: 0.7 },\n      { key: \"grow\", min: 0, max: 1, step: 0.05, default: 0.1 },\n    ],\n  })\n  focusColumn(args: CommandArgs<{ column?: number; dim?: number; grow?: number }> & { duration: number }): Command<LayoutGridProps> {\n    const slots = this._itemSlots()\n    const column = Math.round(args.data?.column ?? 0)\n    return this._focusOn((i) => slots[i]?.meta.kind === \"rectangular\" && slots[i].meta.column === column, slots.length, args)\n  }\n\n  protected override arrangementFor(): RectangularArrangement {\n    return {\n      kind: \"rectangular\",\n      columns: this.columns,\n      fillDirection: this.fillDirection,\n      cellMode: this.cellMode,\n      cellWidth: this.cellWidth,\n      cellHeight: this.cellHeight,\n      columnGap: this.columnGap,\n      rowGap: this.rowGap,\n      lastLineAlign: this.lastLineAlign,\n      rowOffset: this.rowOffset,\n      columnOffset: this.columnOffset,\n    }\n  }\n\n  /** A child set to fill takes its cell, where the cell is not simply the largest child. */\n  protected override itemSpace(count: number, space: Size2D): Size2D {\n    if (this.cellMode === \"fit\") return space\n    return rectangularCell(this.arrangementFor(), count, [], space)\n  }\n}\n", "import { command, node, property, type Command, type CommandArgs, type NodeConfig } from \"@motionscript/core\"\n\nimport {\n  LayoutGrid,\n  normalizeOrder,\n  RADIAL_DIRECTIONS,\n  radialTurnToTop,\n  type LayoutGridProps,\n  type RadialArrangement,\n  type RadialDirection,\n} from \"../kit\"\n\nexport interface RadialGridProps extends LayoutGridProps {\n  radius: number\n  startAngle: number\n  sweep: number\n  direction: RadialDirection\n  rotateItems: boolean\n  spinSpeed: number\n}\n\n/**\n * Children round a circle, or along an arc of one.\n *\n * A full circle spaces the items evenly with none on top of another; an arc\n * puts one at each end. Angles run clockwise from twelve o'clock, so\n * {@link turnTo} can bring any item to the top like a dial.\n */\n@node({\n  key: \"radialGrid\",\n  parentKey: \"node\",\n  forkable: true,\n  layout: {\n    children: \"flow\",\n    acceptsChildren: true,\n    defaultWidthMode: \"hug\",\n    defaultHeightMode: \"hug\",\n  },\n})\nexport class RadialGrid extends LayoutGrid<RadialGridProps> {\n  @property({ default: 200, min: 0, step: 1 }) declare radius: number\n  @property({ default: 0, step: 1, unit: \"°\" }) declare startAngle: number\n  @property({ default: 360, min: -360, max: 360, step: 1, unit: \"°\" }) declare sweep: number\n  @property({ default: \"clockwise\", kind: \"enum\", options: RADIAL_DIRECTIONS }) declare direction: RadialDirection\n  @property({ default: false }) declare rotateItems: boolean\n  @property({ default: 0, step: 1, unit: \"°/s\" }) declare spinSpeed: number\n\n  constructor(props?: NodeConfig<RadialGrid, RadialGridProps>) {\n    super(props)\n  }\n\n  /** Orbit the items round the centre by `degrees` — `360` is one full turn. */\n  @command({ args: [{ key: \"degrees\", step: 15, unit: \"°\", default: 360 }] })\n  spin(args: CommandArgs<{ degrees?: number }> & { duration: number }): Command<RadialGridProps> {\n    const degrees = args.data?.degrees ?? 360\n    return this.to({ data: { startAngle: this.startAngle + degrees }, duration: args.duration, easing: args.easing })\n  }\n\n  /** Turn the ring the shorter way round until an item (by its place in the layers) sits at the top. */\n  @command({ args: [{ key: \"item\", min: 0, step: 1, default: 0 }] })\n  turnTo(args: CommandArgs<{ item?: number }> & { duration: number }): Command<RadialGridProps> {\n    const count = this._itemCount()\n    const slot = normalizeOrder(this.order, count).indexOf(Math.round(args.data?.item ?? 0))\n    const turn = slot < 0 ? 0 : radialTurnToTop(this.arrangementFor(), count, slot)\n    return this.to({ data: { startAngle: this.startAngle + turn }, duration: args.duration, easing: args.easing })\n  }\n\n  @command({ args: [{ key: \"radius\", min: 0, default: 280 }] })\n  radiusTo(args: CommandArgs<{ radius: number }> & { duration: number }): Command<RadialGridProps> {\n    return this.to({ data: { radius: args.data?.radius ?? this.radius }, duration: args.duration, easing: args.easing })\n  }\n\n  /** Open or close the arc like a fan — from `0` to `360` is a reveal of its own. */\n  @command({ args: [{ key: \"sweep\", min: -360, max: 360, unit: \"°\", default: 360 }] })\n  sweepTo(args: CommandArgs<{ sweep: number }> & { duration: number }): Command<RadialGridProps> {\n    return this.to({ data: { sweep: args.data?.sweep ?? this.sweep }, duration: args.duration, easing: args.easing })\n  }\n\n  protected override arrangementFor(): RadialArrangement {\n    return {\n      kind: \"radial\",\n      radius: this.radius,\n      startAngle: this.startAngle,\n      sweep: this.sweep,\n      direction: this.direction,\n      rotateItems: this.rotateItems,\n      spinSpeed: this.spinSpeed,\n    }\n  }\n}\n", "import {\n  command,\n  node,\n  Path,\n  pathOps,\n  PathShape,\n  pathProperty,\n  property,\n  type Command,\n  type CommandArgs,\n  type NodeConfig,\n  type PathData,\n  type Size2D,\n} from \"@motionscript/core\"\n\nimport {\n  findNode2D,\n  frameIn,\n  LayoutGrid,\n  PATH_SPACINGS,\n  PATH_TEMPLATES,\n  staggerArgs,\n  TRANSITION_STAGGER,\n  templatePath,\n  type LayoutGridProps,\n  type PathArrangement,\n  type PathPlacement,\n  type PathSpacing,\n  type PathTemplate,\n  type StaggerArgs,\n} from \"../kit\"\n\n/** A template, or `custom` for the grid's own {@link PathGrid.path}. */\nexport const PATH_GRID_SHAPES = [...PATH_TEMPLATES, \"custom\"] as const\nexport type PathGridShape = (typeof PATH_GRID_SHAPES)[number]\n\nexport interface PathGridProps extends LayoutGridProps {\n  shape: PathGridShape\n  path: PathData\n  pathNode: string\n  spacing: PathSpacing\n  spacingDistance: number\n  offset: number\n  flowSpeed: number\n  trimStart: number\n  trimEnd: number\n  alignToPath: boolean\n}\n\nconst AT_ORIGIN: PathPlacement = { originX: 0, originY: 0, x: 0, y: 0, rotation: 0, scale: 1 }\n\n/** The size a path grid is placed at when nothing says otherwise, since a template is drawn to fill it. */\nconst DEFAULT_SIZE = { width: 640, height: 400 }\n\n/**\n * Children along a path: one of the templates drawn to fill the node's box,\n * a path of the grid's own, or a `Path` node elsewhere in the scene, followed\n * wherever it is.\n *\n * Items are spaced by distance along the curve, so they sit evenly on a tight\n * bend and a straight alike. Animating {@link offset} moves them along it — on\n * a closed path they come round again, which is a conveyor belt for free.\n */\n@node({\n  key: \"pathGrid\",\n  parentKey: \"node\",\n  forkable: true,\n  layout: {\n    children: \"flow\",\n    acceptsChildren: true,\n    defaultWidthMode: \"fixed\",\n    defaultHeightMode: \"fixed\",\n    defaultWidth: DEFAULT_SIZE.width,\n    defaultHeight: DEFAULT_SIZE.height,\n  },\n  seed: { ...DEFAULT_SIZE },\n})\nexport class PathGrid extends LayoutGrid<PathGridProps> {\n  @property({ default: \"circle\", kind: \"enum\", options: PATH_GRID_SHAPES }) declare shape: PathGridShape\n  /** Used when {@link shape} is `custom`: an SVG path, y-down as SVG writes one, centred on its own bounds. */\n  @pathProperty() declare path: PathData\n  /** A path node to follow instead, by id — the items track it wherever it goes. */\n  @property({ default: \"\", kind: \"nodeRef\", nodeTypes: [\"path\"], animatable: false }) declare pathNode: string\n  @property({ default: \"distribute\", kind: \"enum\", options: PATH_SPACINGS }) declare spacing: PathSpacing\n  @property({ default: 80, min: 0, step: 1 }) declare spacingDistance: number\n  /** Share of the path the items are moved along — `1` is once round. */\n  @property({ default: 0, step: 0.01 }) declare offset: number\n  /** Share of the path per second the items travel on their own. */\n  @property({ default: 0, step: 0.01, unit: \"/s\" }) declare flowSpeed: number\n  @property({ default: 0, min: 0, max: 1, step: 0.01 }) declare trimStart: number\n  @property({ default: 1, min: 0, max: 1, step: 0.01 }) declare trimEnd: number\n  @property({ default: true }) declare alignToPath: boolean\n\n  constructor(props?: NodeConfig<PathGrid, PathGridProps>) {\n    super(props)\n  }\n\n  /** Move the items along the path by `loops` — `1` is once round, and they keep their spacing. */\n  @command({ args: [{ key: \"loops\", step: 0.25, default: 1 }] })\n  flow(args: CommandArgs<{ loops?: number }> & { duration: number }): Command<PathGridProps> {\n    const loops = args.data?.loops ?? 1\n    return this.to({ data: { offset: this.offset + loops }, duration: args.duration, easing: args.easing })\n  }\n\n  /** Squeeze the items into part of the path, between two shares of its length. */\n  @command({\n    args: [\n      { key: \"trimStart\", min: 0, max: 1, step: 0.01, default: 0.25 },\n      { key: \"trimEnd\", min: 0, max: 1, step: 0.01, default: 0.75 },\n    ],\n  })\n  trimTo(args: CommandArgs<{ trimStart?: number; trimEnd?: number }> & { duration: number }): Command<PathGridProps> {\n    return this.to({\n      data: { trimStart: args.data?.trimStart ?? this.trimStart, trimEnd: args.data?.trimEnd ?? this.trimEnd },\n      duration: args.duration,\n      easing: args.easing,\n    })\n  }\n\n  /**\n   * Move the items onto another path — a template, or a `Path` node in the\n   * scene. Each item travels from its place on the old path to its place on the\n   * new one; the path itself is not morphed.\n   */\n  @command({\n    args: [\n      { key: \"shape\", kind: \"enum\", options: PATH_GRID_SHAPES, default: \"heart\" },\n      { key: \"pathNode\", kind: \"nodeRef\", nodeTypes: [\"path\"] },\n      ...staggerArgs(TRANSITION_STAGGER),\n    ],\n  })\n  setPath(args: CommandArgs<{ shape?: PathGridShape; pathNode?: string } & StaggerArgs> & { duration: number }): Command<PathGridProps> {\n    const pathNode = args.data?.pathNode ?? \"\"\n    const changes: Partial<PathGridProps> = pathNode ? { pathNode } : { shape: args.data?.shape ?? this.shape, pathNode: \"\" }\n    return this._transitionTo(changes, args)\n  }\n\n  protected override arrangementFor(box: Size2D): PathArrangement {\n    const { path, placement } = this._pathIn(box)\n    return {\n      kind: \"path\",\n      path,\n      placement,\n      spacing: this.spacing,\n      spacingDistance: this.spacingDistance,\n      offset: this.offset,\n      flowSpeed: this.flowSpeed,\n      trimStart: this.trimStart,\n      trimEnd: this.trimEnd,\n      alignToPath: this.alignToPath,\n    }\n  }\n\n  // A template is drawn to fill the box, so a path grid needs one of its own\n  // rather than hugging items whose places depend on it.\n  protected override applyDefaultSize(props?: { readonly width?: unknown; readonly height?: unknown }): void {\n    if (!props || props.width === undefined) this.applyProp(\"width\", DEFAULT_SIZE.width)\n    if (!props || props.height === undefined) this.applyProp(\"height\", DEFAULT_SIZE.height)\n  }\n\n  private _linked: { data: PathData; width: number; height: number; path: PathData } | null = null\n\n  /** The path the items follow, and where its coordinates land in this grid's frame. */\n  private _pathIn(box: Size2D): { path: PathData; placement: PathPlacement } {\n    const linked = this.pathNode ? findNode2D(this, this.pathNode) : null\n    if (linked instanceof PathShape) {\n      return { path: this._unitPath(linked), placement: { ...AT_ORIGIN, ...frameIn(this, linked) } }\n    }\n    if (linked instanceof Path && pathOps.bounds(linked.data)) {\n      // A `Path` draws its data centred on the data's own bounds, at its own position.\n      const bounds = pathOps.bounds(linked.data)!\n      const frame = frameIn(this, linked)\n      return {\n        path: linked.data,\n        placement: {\n          originX: (bounds.minX + bounds.maxX) / 2,\n          originY: (bounds.minY + bounds.maxY) / 2,\n          ...frame,\n        },\n      }\n    }\n    if (this.shape === \"custom\") {\n      const bounds = pathOps.bounds(this.path)\n      if (bounds) {\n        return {\n          path: this.path,\n          placement: {\n            ...AT_ORIGIN,\n            originX: (bounds.minX + bounds.maxX) / 2,\n            originY: (bounds.minY + bounds.maxY) / 2,\n            flipY: true,\n          },\n        }\n      }\n    }\n    const template: PathTemplate = this.shape === \"custom\" ? \"circle\" : this.shape\n    return { path: templatePath(template, box), placement: AT_ORIGIN }\n  }\n\n  /**\n   * A path node's geometry as it draws it: stored in its unit box, y-down, and\n   * scaled to its laid-out size — kept while neither changes, so the path's\n   * measurement is kept with it.\n   */\n  private _unitPath(shape: PathShape): PathData {\n    const { width, height } = shape.layoutBounds\n    const cached = this._linked\n    if (cached && cached.data === shape.data && cached.width === width && cached.height === height) return cached.path\n    const path = pathOps.anchorCommands(pathOps.anchors(shape.data), (p) => ({ x: p.x * width, y: -p.y * height }))\n    this._linked = { data: shape.data, width, height, path }\n    return path\n  }\n}\n", "import { command, node, property, type Command, type CommandArgs, type NodeConfig } from \"@motionscript/core\"\n\nimport {\n  LayoutGrid,\n  normalizeOrder,\n  SPHERE_AXES,\n  SPHERE_FACINGS,\n  sphereFaceForward,\n  wrapDegrees,\n  type LayoutGridProps,\n  type SphereArrangement,\n  type SphereAxis,\n  type SphereFacing,\n} from \"../kit\"\n\nexport interface SphereGridProps extends LayoutGridProps {\n  radius: number\n  yaw: number\n  pitch: number\n  roll: number\n  facing: SphereFacing\n  focalLength: number\n  depthFade: number\n  cullBackfaces: boolean\n  spinSpeed: number\n}\n\nconst AXIS_PROP: Record<SphereAxis, \"yaw\" | \"pitch\" | \"roll\"> = { x: \"pitch\", y: \"yaw\", z: \"roll\" }\n\n/**\n * Children spread over a sphere — a Fibonacci lattice, as even as any number\n * of points gets — and seen through a camera of the grid's own, so the far\n * side is smaller, drawn first, and hidden where a face turns away.\n *\n * `outward` lays each item flat on the surface; `billboard` keeps each one\n * facing the viewer, like labels on a globe. {@link turnTo} brings any item\n * round to the front.\n */\n@node({\n  key: \"sphereGrid\",\n  parentKey: \"node\",\n  forkable: true,\n  layout: {\n    children: \"flow\",\n    acceptsChildren: true,\n    defaultWidthMode: \"hug\",\n    defaultHeightMode: \"hug\",\n  },\n})\nexport class SphereGrid extends LayoutGrid<SphereGridProps> {\n  @property({ default: 220, min: 0, step: 1 }) declare radius: number\n  @property({ default: 0, step: 1, unit: \"°\" }) declare yaw: number\n  @property({ default: 0, step: 1, unit: \"°\" }) declare pitch: number\n  @property({ default: 0, step: 1, unit: \"°\" }) declare roll: number\n  @property({ default: \"outward\", kind: \"enum\", options: SPHERE_FACINGS }) declare facing: SphereFacing\n  @property({ default: 900, min: 100, step: 10 }) declare focalLength: number\n  @property({ default: 0.5, min: 0, max: 1, step: 0.05 }) declare depthFade: number\n  @property({ default: false }) declare cullBackfaces: boolean\n  @property({ default: 0, step: 1, unit: \"°/s\" }) declare spinSpeed: number\n\n  constructor(props?: NodeConfig<SphereGrid, SphereGridProps>) {\n    super(props)\n  }\n\n  /** Turn the sphere about an axis by `degrees` — `y` spins it like a globe. */\n  @command({\n    args: [\n      { key: \"axis\", kind: \"enum\", options: SPHERE_AXES, default: \"y\" },\n      { key: \"degrees\", step: 15, unit: \"°\", default: 360 },\n    ],\n  })\n  spin(args: CommandArgs<{ axis?: SphereAxis; degrees?: number }> & { duration: number }): Command<SphereGridProps> {\n    const key = AXIS_PROP[args.data?.axis ?? \"y\"] ?? \"yaw\"\n    const degrees = args.data?.degrees ?? 360\n    return this.to({ data: { [key]: this[key] + degrees }, duration: args.duration, easing: args.easing })\n  }\n\n  /** Turn the sphere to a set orientation. */\n  @command({\n    args: [\n      { key: \"yaw\", unit: \"°\", default: 45 },\n      { key: \"pitch\", unit: \"°\", default: 20 },\n      { key: \"roll\", unit: \"°\", default: 0 },\n    ],\n  })\n  orientTo(args: CommandArgs<{ yaw?: number; pitch?: number; roll?: number }> & { duration: number }): Command<SphereGridProps> {\n    return this.to({\n      data: { yaw: args.data?.yaw ?? this.yaw, pitch: args.data?.pitch ?? this.pitch, roll: args.data?.roll ?? this.roll },\n      duration: args.duration,\n      easing: args.easing,\n    })\n  }\n\n  /** Turn the sphere the shorter way until an item (by its place in the layers) faces the viewer. */\n  @command({ args: [{ key: \"item\", min: 0, step: 1, default: 0 }] })\n  turnTo(args: CommandArgs<{ item?: number }> & { duration: number }): Command<SphereGridProps> {\n    const count = this._itemCount()\n    const slot = normalizeOrder(this.order, count).indexOf(Math.round(args.data?.item ?? 0))\n    if (slot < 0) return this.to({ data: {}, duration: args.duration })\n    const facing = sphereFaceForward(count, slot)\n    // The yaw the clock has added is part of where the item is now.\n    const spun = this.spinSpeed * this.time.total\n    return this.to({\n      data: {\n        yaw: this.yaw + wrapDegrees(facing.yaw - (this.yaw + spun)),\n        pitch: this.pitch + wrapDegrees(facing.pitch - this.pitch),\n        roll: 0,\n      },\n      duration: args.duration,\n      easing: args.easing,\n    })\n  }\n\n  @command({ args: [{ key: \"radius\", min: 0, default: 300 }] })\n  radiusTo(args: CommandArgs<{ radius: number }> & { duration: number }): Command<SphereGridProps> {\n    return this.to({ data: { radius: args.data?.radius ?? this.radius }, duration: args.duration, easing: args.easing })\n  }\n\n  /** Dolly the camera: a shorter focal length exaggerates the depth, a longer one flattens it. */\n  @command({ args: [{ key: \"focalLength\", min: 100, default: 600 }] })\n  focalLengthTo(args: CommandArgs<{ focalLength: number }> & { duration: number }): Command<SphereGridProps> {\n    return this.to({\n      data: { focalLength: args.data?.focalLength ?? this.focalLength },\n      duration: args.duration,\n      easing: args.easing,\n    })\n  }\n\n  protected override arrangementFor(): SphereArrangement {\n    return {\n      kind: \"sphere\",\n      radius: this.radius,\n      yaw: this.yaw,\n      pitch: this.pitch,\n      roll: this.roll,\n      facing: this.facing,\n      focalLength: this.focalLength,\n      depthFade: this.depthFade,\n      cullBackfaces: this.cullBackfaces,\n      spinSpeed: this.spinSpeed,\n    }\n  }\n}\n", "import { PathGrid } from \"./path-grid\"\nimport { RadialGrid } from \"./radial-grid\"\nimport { RectangularGrid } from \"./rectangular-grid\"\nimport { SphereGrid } from \"./sphere-grid\"\n\n/**\n * Every node type this package publishes.\n *\n * A host registers these by handing the array to an engine —\n * `new Engine(platform, { nodes: NODES })` — which reads each class's `@node()`\n * key. Listing class **values** is also what survives bundling: this package\n * declares `sideEffects: false`, and a document names a node type by string, so\n * an import kept only for its side effect is exactly what gets shaken out.\n */\nexport const NODES = [RectangularGrid, RadialGrid, PathGrid, SphereGrid]\n"],
+  "mappings": "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",
+  "names": ["command", "easeInOut", "node", "property", "RectangularGrid", "LayoutGrid", "props", "args", "columns", "data", "sizes", "from", "rectangularCell", "contentBoxOf", "width", "height", "t", "easeInOut", "slots", "row", "i", "column", "count", "space", "__decorate", "property", "FILL_DIRECTIONS", "CELL_MODES", "LINE_ALIGNS", "command", "staggerArgs", "TRANSITION_STAGGER", "node", "command", "node", "property", "RadialGrid", "LayoutGrid", "props", "args", "degrees", "count", "slot", "normalizeOrder", "turn", "radialTurnToTop", "__decorate", "property", "RADIAL_DIRECTIONS", "command", "node", "command", "node", "Path", "pathOps", "PathShape", "pathProperty", "property", "PATH_GRID_SHAPES", "PATH_TEMPLATES", "AT_ORIGIN", "DEFAULT_SIZE", "PathGrid", "LayoutGrid", "props", "args", "loops", "pathNode", "changes", "box", "path", "placement", "linked", "findNode2D", "PathShape", "frameIn", "Path", "pathOps", "bounds", "frame", "template", "templatePath", "shape", "width", "height", "cached", "p", "__decorate", "property", "pathProperty", "PATH_SPACINGS", "command", "staggerArgs", "TRANSITION_STAGGER", "node", "command", "node", "property", "AXIS_PROP", "SphereGrid", "LayoutGrid", "props", "args", "key", "degrees", "count", "slot", "normalizeOrder", "facing", "sphereFaceForward", "spun", "wrapDegrees", "__decorate", "property", "SPHERE_FACINGS", "command", "SPHERE_AXES", "node", "NODES", "RectangularGrid", "RadialGrid", "PathGrid", "SphereGrid"]
+}

package/dist/browser/kit.js

@@ -0,0 +1,2 @@
+import{A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z}from"./chunks/chunk-PB3E5HQV.js";export{m as CELL_MODES,l as FILL_DIRECTIONS,O as LAYOUT_GRID_TYPES,n as LINE_ALIGNS,Q as LayoutGrid,e as PATH_SPACINGS,x as PATH_TEMPLATES,g as RADIAL_DIRECTIONS,H as REVEAL_STYLES,s as SPHERE_AXES,r as SPHERE_FACINGS,E as STAGGER_ORDERS,P as TRANSITION_STAGGER,I as WAVE_STYLES,J as applyItemEffects,b as blendSlot,R as contentBoxOf,t as fibonacciPoint,S as findNode2D,A as focalLengthOf,T as frameIn,D as hashSeed,d as largest,K as normalizeOrder,u as orient,M as parseOrder,f as pathSlots,h as radialAngles,i as radialSlots,j as radialTurnToTop,p as rectangularCell,o as rectangularShape,q as rectangularSlots,B as seededRandom,C as shuffled,a as slot,L as slotOfItem,z as slotsOf,w as sphereFaceForward,v as sphereSlots,c as spreadSlot,N as staggerArgs,G as staggerProgress,F as staggerRanks,y as templatePath,k as wrapDegrees};
+//# sourceMappingURL=kit.js.map

package/dist/browser/kit.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/browser/manifest.json

@@ -0,0 +1,12 @@
+{
+  "name": "@motionscript/layout-grid",
+  "version": "0.1.0-alpha.0",
+  "exports": {
+    ".": "dist/browser/index.js",
+    "./kit": "dist/browser/kit.js"
+  },
+  "peers": [
+    "@motionscript/core"
+  ],
+  "assets": {}
+}

package/dist/engine.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The layout grid **kit**: what the four grids share, and what a copied one does
+ * not copy.
+ *
+ * `ms add` writes a grid's own files into your project and rewrites its reach for
+ * these to `@motionscript/layout-grid`, so the shared parts stay a real
+ * dependency. That is not a size decision. The engine keys prop machinery to
+ * class identity — `@property` installs against the class it was applied with —
+ * so a second copy of `LayoutGrid` is a second class answering to one name, and
+ * a morph from one grid to another only finds grids of the class it knows.
+ */
+export * from "./kit/index.js";
+//# sourceMappingURL=engine.d.ts.map

package/dist/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../src/engine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,cAAc,OAAO,CAAA"}

package/dist/engine.js

@@ -0,0 +1,13 @@
+/**
+ * The layout grid **kit**: what the four grids share, and what a copied one does
+ * not copy.
+ *
+ * `ms add` writes a grid's own files into your project and rewrites its reach for
+ * these to `@motionscript/layout-grid`, so the shared parts stay a real
+ * dependency. That is not a size decision. The engine keys prop machinery to
+ * class identity — `@property` installs against the class it was applied with —
+ * so a second copy of `LayoutGrid` is a second class answering to one name, and
+ * a morph from one grid to another only finds grids of the class it knows.
+ */
+export * from "./kit/index.js";
+//# sourceMappingURL=engine.js.map

package/dist/engine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.js","sourceRoot":"","sources":["../src/engine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,cAAc,OAAO,CAAA","sourcesContent":["/**\n * The layout grid **kit**: what the four grids share, and what a copied one does\n * not copy.\n *\n * `ms add` writes a grid's own files into your project and rewrites its reach for\n * these to `@motionscript/layout-grid`, so the shared parts stay a real\n * dependency. That is not a size decision. The engine keys prop machinery to\n * class identity — `@property` installs against the class it was applied with —\n * so a second copy of `LayoutGrid` is a second class answering to one name, and\n * a morph from one grid to another only finds grids of the class it knows.\n */\nexport * from \"./kit\"\n"]}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./rectangular-grid/index.js";
+export * from "./radial-grid/index.js";
+export * from "./path-grid/index.js";
+export * from "./sphere-grid/index.js";
+export * from "./engine.js";
+export { NODES } from "./nodes.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAA;AAClC,cAAc,eAAe,CAAA;AAC7B,cAAc,aAAa,CAAA;AAC3B,cAAc,eAAe,CAAA;AAC7B,cAAc,UAAU,CAAA;AACxB,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA"}

package/dist/index.js

@@ -0,0 +1,7 @@
+export * from "./rectangular-grid/index.js";
+export * from "./radial-grid/index.js";
+export * from "./path-grid/index.js";
+export * from "./sphere-grid/index.js";
+export * from "./engine.js";
+export { NODES } from "./nodes.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAA;AAClC,cAAc,eAAe,CAAA;AAC7B,cAAc,aAAa,CAAA;AAC3B,cAAc,eAAe,CAAA;AAC7B,cAAc,UAAU,CAAA;AACxB,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA","sourcesContent":["export * from \"./rectangular-grid\"\nexport * from \"./radial-grid\"\nexport * from \"./path-grid\"\nexport * from \"./sphere-grid\"\nexport * from \"./engine\"\nexport { NODES } from \"./nodes\"\n"]}

package/dist/kit/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./slots/index.js";
+export * from "./stagger.js";
+export * from "./item-effects.js";
+export * from "./order.js";
+export * from "./random.js";
+export * from "./layout-grid.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/kit/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAA;AACvB,cAAc,WAAW,CAAA;AACzB,cAAc,gBAAgB,CAAA;AAC9B,cAAc,SAAS,CAAA;AACvB,cAAc,UAAU,CAAA;AACxB,cAAc,eAAe,CAAA"}

package/dist/kit/index.js

@@ -0,0 +1,7 @@
+export * from "./slots/index.js";
+export * from "./stagger.js";
+export * from "./item-effects.js";
+export * from "./order.js";
+export * from "./random.js";
+export * from "./layout-grid.js";
+//# sourceMappingURL=index.js.map

package/dist/kit/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/kit/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAA;AACvB,cAAc,WAAW,CAAA;AACzB,cAAc,gBAAgB,CAAA;AAC9B,cAAc,SAAS,CAAA;AACvB,cAAc,UAAU,CAAA;AACxB,cAAc,eAAe,CAAA","sourcesContent":["export * from \"./slots\"\nexport * from \"./stagger\"\nexport * from \"./item-effects\"\nexport * from \"./order\"\nexport * from \"./random\"\nexport * from \"./layout-grid\"\n"]}

package/dist/kit/item-effects.d.ts

@@ -0,0 +1,37 @@
+import type { Size2D } from "@motionscript/core";
+import type { Slot } from "./slots/index.js";
+/**
+ * What an item does on its way in (or out): grow from nothing, fade, fly out of
+ * the grid's centre, rise into place, flip up, or spin in.
+ */
+export declare const REVEAL_STYLES: readonly ["scale", "fade", "center", "rise", "flip", "spin"];
+export type RevealStyle = (typeof REVEAL_STYLES)[number];
+/** What a wave does to each item as it passes. */
+export declare const WAVE_STYLES: readonly ["scale", "lift", "fade", "spin"];
+export type WaveStyle = (typeof WAVE_STYLES)[number];
+/**
+ * How far into view each item is, `1` shown and `0` gone — past `1` on the
+ * way to it under an overshooting ease. Absent means every item is shown.
+ */
+export interface RevealState {
+    style: RevealStyle;
+    values: readonly number[];
+}
+/** Each item's share of the wave passing through it, `0` at rest and `1` at the crest. */
+export interface WaveState {
+    style: WaveStyle;
+    /** How big the crest is — a share of the item's size, opacity or a turn, by style. */
+    amount: number;
+    values: readonly number[];
+}
+/** Each item's emphasis: `1` the focus, `-1` pushed back, `0` untouched. */
+export interface FocusState {
+    /** How far the others fade, `0..1`. */
+    dim: number;
+    /** How much the focus grows, as a share of its size; the others shrink by half that. */
+    grow: number;
+    values: readonly number[];
+}
+/** Layer item `i`'s reveal, wave and focus onto its slot, in place. */
+export declare function applyItemEffects(s: Slot, i: number, size: Size2D, reveal: RevealState | null | undefined, wave: WaveState | null | undefined, focus: FocusState | null | undefined): void;
+//# sourceMappingURL=item-effects.d.ts.map

package/dist/kit/item-effects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"item-effects.d.ts","sourceRoot":"","sources":["../../src/kit/item-effects.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAA;AAEhD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAEnC;;;GAGG;AACH,eAAO,MAAM,aAAa,8DAA+D,CAAA;AACzF,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,CAAC,CAAA;AAExD,kDAAkD;AAClD,eAAO,MAAM,WAAW,4CAA6C,CAAA;AACrE,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAA;AAEpD;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,WAAW,CAAA;IAClB,MAAM,EAAE,SAAS,MAAM,EAAE,CAAA;CAC1B;AAED,0FAA0F;AAC1F,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,SAAS,CAAA;IAChB,sFAAsF;IACtF,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,SAAS,MAAM,EAAE,CAAA;CAC1B;AAED,4EAA4E;AAC5E,MAAM,WAAW,UAAU;IACzB,uCAAuC;IACvC,GAAG,EAAE,MAAM,CAAA;IACX,wFAAwF;IACxF,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,SAAS,MAAM,EAAE,CAAA;CAC1B;AAED,uEAAuE;AACvE,wBAAgB,gBAAgB,CAC9B,CAAC,EAAE,IAAI,EACP,CAAC,EAAE,MAAM,EACT,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,EACtC,IAAI,EAAE,SAAS,GAAG,IAAI,GAAG,SAAS,EAClC,KAAK,EAAE,UAAU,GAAG,IAAI,GAAG,SAAS,GACnC,IAAI,CAIN"}

package/dist/kit/item-effects.js

@@ -0,0 +1,76 @@
+/**
+ * What an item does on its way in (or out): grow from nothing, fade, fly out of
+ * the grid's centre, rise into place, flip up, or spin in.
+ */
+export const REVEAL_STYLES = ["scale", "fade", "center", "rise", "flip", "spin"];
+/** What a wave does to each item as it passes. */
+export const WAVE_STYLES = ["scale", "lift", "fade", "spin"];
+/** Layer item `i`'s reveal, wave and focus onto its slot, in place. */
+export function applyItemEffects(s, i, size, reveal, wave, focus) {
+    if (reveal)
+        applyReveal(s, reveal.style, reveal.values[i] ?? 1, size);
+    if (wave)
+        applyWave(s, wave, wave.values[i] ?? 0, size);
+    if (focus)
+        applyFocus(s, focus, focus.values[i] ?? 0);
+}
+function applyReveal(s, style, v, size) {
+    if (v === 1)
+        return;
+    const shown = clamp01(v);
+    switch (style) {
+        case "fade":
+            s.opacity *= shown;
+            break;
+        case "center":
+            s.x *= v;
+            s.y *= v;
+            s.depth *= v;
+            s.opacity *= clamp01(v * 4);
+            break;
+        case "rise":
+            s.y -= (1 - v) * Math.max(40, size.height);
+            s.opacity *= shown;
+            break;
+        case "flip":
+            s.rotationX += (1 - v) * 90;
+            break;
+        case "spin":
+            s.rotation -= (1 - v) * 180;
+            s.scale *= Math.max(0, v);
+            break;
+        default:
+            s.scale *= Math.max(0, v);
+    }
+}
+function applyWave(s, wave, w, size) {
+    if (w === 0)
+        return;
+    switch (wave.style) {
+        case "lift":
+            s.y += wave.amount * w * Math.max(40, size.height);
+            break;
+        case "fade":
+            s.opacity *= clamp01(1 - wave.amount * w);
+            break;
+        case "spin":
+            s.rotation += wave.amount * w * 360;
+            break;
+        default:
+            s.scale *= 1 + wave.amount * w;
+    }
+}
+function applyFocus(s, focus, f) {
+    if (f === 0)
+        return;
+    if (f > 0) {
+        s.scale *= 1 + focus.grow * f;
+        return;
+    }
+    s.opacity *= clamp01(1 - focus.dim * -f);
+    s.scale *= Math.max(0, 1 + focus.grow * 0.5 * f);
+}
+function clamp01(v) {
+    return v < 0 ? 0 : v > 1 ? 1 : v;
+}
+//# sourceMappingURL=item-effects.js.map

package/dist/kit/item-effects.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"item-effects.js","sourceRoot":"","sources":["../../src/kit/item-effects.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Size2D } from \"@motionscript/core\"\n\nimport type { Slot } from \"./slots\"\n\n/**\n * What an item does on its way in (or out): grow from nothing, fade, fly out of\n * the grid's centre, rise into place, flip up, or spin in.\n */\nexport const REVEAL_STYLES = [\"scale\", \"fade\", \"center\", \"rise\", \"flip\", \"spin\"] as const\nexport type RevealStyle = (typeof REVEAL_STYLES)[number]\n\n/** What a wave does to each item as it passes. */\nexport const WAVE_STYLES = [\"scale\", \"lift\", \"fade\", \"spin\"] as const\nexport type WaveStyle = (typeof WAVE_STYLES)[number]\n\n/**\n * How far into view each item is, `1` shown and `0` gone — past `1` on the\n * way to it under an overshooting ease. Absent means every item is shown.\n */\nexport interface RevealState {\n  style: RevealStyle\n  values: readonly number[]\n}\n\n/** Each item's share of the wave passing through it, `0` at rest and `1` at the crest. */\nexport interface WaveState {\n  style: WaveStyle\n  /** How big the crest is — a share of the item's size, opacity or a turn, by style. */\n  amount: number\n  values: readonly number[]\n}\n\n/** Each item's emphasis: `1` the focus, `-1` pushed back, `0` untouched. */\nexport interface FocusState {\n  /** How far the others fade, `0..1`. */\n  dim: number\n  /** How much the focus grows, as a share of its size; the others shrink by half that. */\n  grow: number\n  values: readonly number[]\n}\n\n/** Layer item `i`'s reveal, wave and focus onto its slot, in place. */\nexport function applyItemEffects(\n  s: Slot,\n  i: number,\n  size: Size2D,\n  reveal: RevealState | null | undefined,\n  wave: WaveState | null | undefined,\n  focus: FocusState | null | undefined,\n): void {\n  if (reveal) applyReveal(s, reveal.style, reveal.values[i] ?? 1, size)\n  if (wave) applyWave(s, wave, wave.values[i] ?? 0, size)\n  if (focus) applyFocus(s, focus, focus.values[i] ?? 0)\n}\n\nfunction applyReveal(s: Slot, style: RevealStyle, v: number, size: Size2D): void {\n  if (v === 1) return\n  const shown = clamp01(v)\n  switch (style) {\n    case \"fade\":\n      s.opacity *= shown\n      break\n    case \"center\":\n      s.x *= v\n      s.y *= v\n      s.depth *= v\n      s.opacity *= clamp01(v * 4)\n      break\n    case \"rise\":\n      s.y -= (1 - v) * Math.max(40, size.height)\n      s.opacity *= shown\n      break\n    case \"flip\":\n      s.rotationX += (1 - v) * 90\n      break\n    case \"spin\":\n      s.rotation -= (1 - v) * 180\n      s.scale *= Math.max(0, v)\n      break\n    default:\n      s.scale *= Math.max(0, v)\n  }\n}\n\nfunction applyWave(s: Slot, wave: WaveState, w: number, size: Size2D): void {\n  if (w === 0) return\n  switch (wave.style) {\n    case \"lift\":\n      s.y += wave.amount * w * Math.max(40, size.height)\n      break\n    case \"fade\":\n      s.opacity *= clamp01(1 - wave.amount * w)\n      break\n    case \"spin\":\n      s.rotation += wave.amount * w * 360\n      break\n    default:\n      s.scale *= 1 + wave.amount * w\n  }\n}\n\nfunction applyFocus(s: Slot, focus: FocusState, f: number): void {\n  if (f === 0) return\n  if (f > 0) {\n    s.scale *= 1 + focus.grow * f\n    return\n  }\n  s.opacity *= clamp01(1 - focus.dim * -f)\n  s.scale *= Math.max(0, 1 + focus.grow * 0.5 * f)\n}\n\nfunction clamp01(v: number): number {\n  return v < 0 ? 0 : v > 1 ? 1 : v\n}\n"]}

package/dist/kit/layout-grid.d.ts

@@ -0,0 +1,243 @@
+import { Node2D, type BoxBounds, type ChildPlacement, type Command, type CommandArgs, type MeasureContext2D, type EasingFunction, type Node2DProps, type Size2D, type SizeConstraints, type SpaceCamera } from "@motionscript/core";
+import { type FocusState, type RevealState, type RevealStyle, type WaveState, type WaveStyle } from "./item-effects.js";
+import { type Arrangement, type Slot } from "./slots/index.js";
+import { type StaggerOrder } from "./stagger.js";
+/** An arrangement a grid is leaving, kept as data so its slots can be worked out afresh every frame. */
+export interface GridSnapshot {
+    arrangement: Arrangement;
+    /** The grid the arrangement was borrowed from, or `""` for the grid's own. */
+    source: string;
+    order: readonly number[];
+    spread: number;
+}
+/** A change of arrangement under way: where the items are coming from, and how far each has come. */
+export interface GridTransition {
+    from: GridSnapshot;
+    /** Each item's eased, staggered progress, `0..1`. */
+    mix: readonly number[];
+}
+export interface LayoutGridProps extends Node2DProps {
+    /** Items in slot order: slot `k` holds child `order[k]`. Empty is the children's own order. */
+    order: number[];
+    /** `0` gathers every item at the centre, `1` is the arrangement, past `1` pushes them apart. */
+    spread: number;
+    /** Another grid whose arrangement this one takes on — what {@link LayoutGrid.morphInto} animates. */
+    arrangeLike: string;
+    revealState: RevealState | null;
+    waveState: WaveState | null;
+    focusState: FocusState | null;
+    transition: GridTransition | null;
+}
+/** What a command that moves the items to new slots is built from. */
+export interface TransitionArgs {
+    data?: StaggerArgs;
+    duration: number;
+    easing?: EasingFunction;
+}
+/** The stagger options every per-item command takes. */
+export interface StaggerArgs {
+    staggerOrder?: StaggerOrder;
+    /** `0..0.95`: how much of the command's length the items' offsets take up. */
+    stagger?: number;
+}
+/** `@command` descriptors for {@link StaggerArgs}, `stagger` defaulting to `fallback`. */
+export declare function staggerArgs(fallback: number): readonly [{
+    readonly key: "staggerOrder";
+    readonly kind: "enum";
+    readonly options: readonly ["index", "reverse", "random", "centerOut", "edgesIn", "row", "column", "angle", "path", "depth"];
+    readonly default: "index";
+}, {
+    readonly key: "stagger";
+    readonly min: 0;
+    readonly max: 0.95;
+    readonly step: 0.05;
+    readonly default: number;
+}];
+/**
+ * Every grid's document key — what a reference to "another grid" may name. A
+ * `nodeRef` descriptor carries it as `nodeTypes`, for a host's picker to offer
+ * only those.
+ */
+export declare const LAYOUT_GRID_TYPES: readonly ["rectangularGrid", "radialGrid", "pathGrid", "sphereGrid"];
+/** The stagger a move to new slots takes when its command states none. */
+export declare const TRANSITION_STAGGER = 0.3;
+/**
+ * The base of every grid: a container that places each of its children in a
+ * slot of an arrangement — a rectangular grid, a ring, a path, a sphere.
+ *
+ * ## Children only
+ *
+ * The items are the children, in layer order. A child's slot is a parent
+ * transform on it, so its own `x`/`y`/`rotation`/`scale` — and any command on
+ * them — still work, relative to the slot. A group is one item; a grid of
+ * grids is a grid of items that happen to be grids.
+ *
+ * ## One pass
+ *
+ * Every frame: measure the children, ask the arrangement for its slots (a pure
+ * function of the props, the sizes and the clock), blend them from where a
+ * transition is leaving, and layer on the per-item effects — reveal, wave,
+ * focus. What is left is each child's box and {@link ChildPlacement}, which the
+ * renderer, picking and `global` all read, so a selection outline lands on
+ * the pixels even on a sphere.
+ *
+ * ## Commands
+ *
+ * Every command is a pure function of time, like the rest of the library. The
+ * per-item ones stagger *inside* their duration — a one-second reveal takes one
+ * second for four children or four hundred — and write their per-item state
+ * into props ({@link revealState} and its siblings), which is what keeps them
+ * seekable. The ones that change the arrangement itself (a reorder, a morph, a
+ * column count) keep the arrangement they are leaving as data and blend each
+ * item from its old slot to its new one.
+ */
+export declare abstract class LayoutGrid<P extends LayoutGridProps = LayoutGridProps> extends Node2D<P> {
+    order: number[];
+    spread: number;
+    arrangeLike: string;
+    revealState: RevealState | null | undefined;
+    waveState: WaveState | null | undefined;
+    focusState: FocusState | null | undefined;
+    transition: GridTransition | null | undefined;
+    /**
+     * Bring the items in, one after another. Every item starts hidden, so place
+     * it where the grid enters — or after a {@link conceal}.
+     */
+    reveal(args: CommandArgs<{
+        style?: RevealStyle;
+    } & StaggerArgs> & {
+        duration: number;
+    }): Command<LayoutGridProps>;
+    /** Take the items out, one after another — {@link reveal} in reverse. They stay hidden after. */
+    conceal(args: CommandArgs<{
+        style?: RevealStyle;
+    } & StaggerArgs> & {
+        duration: number;
+    }): Command<LayoutGridProps>;
+    /** Send a ripple through the items that swells each in turn and settles back. */
+    wave(args: CommandArgs<{
+        style?: WaveStyle;
+        amount?: number;
+    } & StaggerArgs> & {
+        duration: number;
+    }): Command<LayoutGridProps>;
+    /** Bring one item (by its place in the layers, from 0) forward and push the rest back. */
+    focus(args: CommandArgs<{
+        item?: number;
+        dim?: number;
+        grow?: number;
+    }> & {
+        duration: number;
+    }): Command<LayoutGridProps>;
+    /** Bring every item back to even. */
+    unfocus(args: CommandArgs<Record<string, never>> & {
+        duration: number;
+    }): Command<LayoutGridProps>;
+    /** Gather the items toward the centre (`0`), back to the arrangement (`1`), or push them apart. */
+    spreadTo(args: CommandArgs<{
+        spread: number;
+    }> & {
+        duration: number;
+    }): Command<P>;
+    /** Send every item to a random slot. The same `seed` always deals the same way. */
+    shuffle(args: CommandArgs<{
+        seed?: number;
+    } & StaggerArgs> & {
+        duration: number;
+    }): Command<P>;
+    /** Two items trade places, by their place in the layers. */
+    swap(args: CommandArgs<{
+        first?: number;
+        second?: number;
+    } & StaggerArgs> & {
+        duration: number;
+    }): Command<P>;
+    /** Move the items into a new order — a list of layer indices, first slot first, like `"2, 0, 1"`. */
+    reorder(args: CommandArgs<{
+        order?: string | number[];
+    } & StaggerArgs> & {
+        duration: number;
+    }): Command<P>;
+    /**
+     * Move every item into another grid's arrangement — a grid into a ring, a ring
+     * onto a sphere — and keep following it. An empty `target` morphs back to
+     * this grid's own.
+     */
+    morphInto(args: CommandArgs<{
+        target?: string;
+    } & StaggerArgs> & {
+        duration: number;
+    }): Command<P>;
+    /** This grid's own arrangement, for a content box of `box`. */
+    protected abstract arrangementFor(box: Size2D): Arrangement;
+    protected applyDefaultSize(props?: {
+        readonly width?: unknown;
+        readonly height?: unknown;
+    }): void;
+    /** The room each item is measured in — the whole content box, unless an arrangement has cells. */
+    protected itemSpace(_count: number, space: Size2D, _sizes?: readonly Size2D[]): Size2D;
+    measure(constraints: SizeConstraints, scope: MeasureContext2D): Partial<Size2D>;
+    protected layoutChildren(rect: BoxBounds, scope: MeasureContext2D): void;
+    _placementOf(child: Node2D): ChildPlacement | null;
+    /**
+     * A grid whose arrangement has depth is seen through a camera of its own,
+     * which paints its items far to near — unless it already sits in a space (an
+     * orbit camera, a 3D stage), where its items join that one and its camera.
+     */
+    _spaceCamera(): SpaceCamera | null;
+    private readonly _placements;
+    /** What {@link measure} found, for {@link layoutChildren} to reuse in the same pass. */
+    private _measured;
+    /** Each item's slot from the last layout — what a command ranks its stagger by. */
+    private _slots;
+    /** Each item's size from the last layout. */
+    private _sizes;
+    /** The last layout's camera distance, `0` while flat. */
+    private _focal;
+    private _borrowCache;
+    /** How many items a command built now will act on. */
+    protected _itemCount(): number;
+    /** Each item's slot as it stands, for a command being built — the last layout's where it still fits. */
+    protected _itemSlots(): Slot[];
+    /** The item sizes the last layout found. */
+    protected _itemSizes(): readonly Size2D[];
+    /** Each item's start in a stagger. A random order is seeded by the node's id, so it never changes between builds. */
+    protected _ranks(order: StaggerOrder | undefined): number[];
+    /**
+     * Write `changes` to the arrangement and move each item from its slot in the
+     * one being left to its slot in the new one, staggered.
+     */
+    protected _transitionTo(changes: Partial<P>, args: TransitionArgs, stagger?: number): Command<P>;
+    /** Emphasise the items `isFocus` picks and push the rest back. */
+    protected _focusOn(isFocus: (item: number) => boolean, count: number, args: CommandArgs<{
+        dim?: number;
+        grow?: number;
+    }> & {
+        duration: number;
+    }): Command<LayoutGridProps>;
+    private _snapshot;
+    private _measureItems;
+    /** Where each item sits in the arrangement it is heading for, before any transition or effect. */
+    private _targetSlots;
+    /** Each item's final slot this frame: the target, blended from any transition, with its effects on. */
+    private _resolve;
+    /** Whether an ancestor places this grid in a space, as `spaceFrameOf` walks it. */
+    private _inSpace;
+    /** The grid {@link arrangeLike} names, when it names another grid in this tree. */
+    private _borrowed;
+    private _gridById;
+    /** `slots`, laid out in `source`'s frame, moved into this grid's. */
+    private _fromGrid;
+}
+/** A node's content box: its laid-out size inside its padding. */
+export declare function contentBoxOf(grid: Node2D): Size2D;
+/** The 2D node `id` names in the tree `from` is in, or `null`. */
+export declare function findNode2D(from: Node2D, id: string): Node2D | null;
+/** Where `node`'s frame sits in `grid`'s: offset, turn and scale, y-up. */
+export declare function frameIn(grid: Node2D, node: Node2D): {
+    x: number;
+    y: number;
+    rotation: number;
+    scale: number;
+};
+//# sourceMappingURL=layout-grid.d.ts.map

package/dist/kit/layout-grid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout-grid.d.ts","sourceRoot":"","sources":["../../src/kit/layout-grid.ts"],"names":[],"mappings":"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"}