@weasel-js/ui 1.6.1 → 1.7.1

package/dist/chunks/useReorderDragList-B_-5L5Gu.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useReorderDragList-B_-5L5Gu.js","names":["isInControlWithin","IDLE","unlockedSegment","lo","i","sourceIndex","items","hi","draggedIdsFor","index","selectedIds","id","it","x","isNoopDrop","indices","draggedIds","a","b","contiguous","prev","v","first","last","targetIndex","useReorderDragList","optsRef","useRef","opts","containerRef","dragRef","state","setState","useState","computeTargetIndex","useCallback","c","sel","rows","el","raw","row","clientY","refCb","reset","onPointerDownRow","container","e","mods","pressed","child","grab","ghostAt","ev","startThresholdDrag","drop","onPress","swallowNextClick","ids","at","target","delta","onReorder","swallow"],"sources":["../../src/useReorderDragList.ts"],"sourcesContent":["import { useCallback, useEffect, useRef, useState } from 'react';\nimport type { ReactNode, PointerEvent as ReactPointerEvent, RefCallback } from 'react';\nimport { startThresholdDrag, type ThresholdDragHandle } from '@weasel-js/core';\nimport { isInControlWithin } from './interactiveTarget';\n\n/** One row in a reorderable list. */\nexport interface ReorderItem {\n  id: string;\n  label: ReactNode;\n  /** Locked rows cannot be dragged, cannot be crossed by drops, and\n   *  never combine with other rows in a multi-selection. */\n  locked?: boolean;\n}\n\n/**\n * Options for {@link useReorderDragList}. `onReorder` receives the dragged ids\n * and the index they were dropped at, measured against the pre-drag `items`.\n */\nexport interface UseReorderDragListOptions {\n  items: ReorderItem[];\n  selectedIds: string[];\n  onReorder(ids: string[], targetIndex: number): void;\n  /** A press that was released without ever engaging a drag — the click a\n   *  list row means by it. Fires for locked rows too, which can be selected\n   *  but not dragged. Modifiers are read at press, not at release. When this\n   *  is given, the DOM click that follows the press is dropped, so a row that\n   *  also handles `click` sees one press, not two. A press that starts on a\n   *  control inside the row (a toggle) is left to the control. */\n  onPress?(id: string, mods: PressModifiers): void;\n  /** Pointer-move distance (px) before pending drag engages. Default 4. */\n  threshold?: number;\n  /** Selector matching the container's children that are rows, for a list\n   *  that interleaves other elements (a table's detail rows). Default: every\n   *  child is a row. */\n  rowSelector?: string;\n}\n\n/** Modifier keys held when a press began. */\nexport interface PressModifiers {\n  shiftKey: boolean;\n  ctrlKey: boolean;\n  metaKey: boolean;\n  altKey: boolean;\n}\n\n/**\n * Where a drag's ghost goes: the dragged rows, drawn again with their top-left\n * at a client-space point, so the row that was grabbed stays under the pointer\n * where it was picked up. `width` is the grabbed row's.\n */\nexport interface ReorderGhost {\n  ids: readonly string[];\n  left: number;\n  top: number;\n  width: number;\n}\n\n/**\n * Live drag state for rendering feedback: which ids are being dragged, the\n * insertion index the drop would use, and where their ghost goes. All `null`\n * when no drag is engaged.\n */\nexport interface ReorderDragState {\n  draggedIds: string[] | null;\n  targetIndex: number | null;\n  ghost: ReorderGhost | null;\n}\n\nconst IDLE: ReorderDragState = { draggedIds: null, targetIndex: null, ghost: null };\n\n/**\n * A `ref` for the list container, an `onPointerDown` for each row, and the\n * live {@link ReorderDragState}. The container ref is required, not optional\n * decoration: it is what the drop index is measured against and what the\n * pointer session is opened on.\n */\nexport interface ReorderDragHandlers {\n  rowProps(id: string, index: number): { onPointerDown(e: ReactPointerEvent): void };\n  containerProps: {\n    ref: RefCallback<HTMLElement>;\n  };\n  state: ReorderDragState;\n  /**\n   * Move the row at `index` one place up (`-1`) or down (`1`) — the keyboard\n   * reorder. It moves what a drag of that row would: the whole selection if\n   * the row is in it, else the row alone, never across a locked row. Calls\n   * `onReorder` and returns `true`, or returns `false` when nothing can move.\n   */\n  nudge(id: string, index: number, delta: -1 | 1): boolean;\n}\n\n/**\n * The half-open run of indices a row at `sourceIndex` may be dropped into:\n * bounded by the nearest locked row above and below it, so a locked row is a\n * wall in both directions rather than a global ceiling.\n */\nfunction unlockedSegment(items: readonly ReorderItem[], sourceIndex: number): [number, number] {\n  let lo = 0;\n  for (let i = sourceIndex - 1; i >= 0; i--) {\n    if (items[i]?.locked) { lo = i + 1; break; }\n  }\n  let hi = items.length;\n  for (let i = sourceIndex + 1; i < items.length; i++) {\n    if (items[i]?.locked) { hi = i; break; }\n  }\n  return [lo, hi];\n}\n\n/** What a drag of the row at `index` carries: the selection within its segment if the row is selected, else the row. */\nfunction draggedIdsFor(\n  items: readonly ReorderItem[],\n  selectedIds: readonly string[],\n  id: string,\n  index: number,\n): string[] {\n  const [lo, hi] = unlockedSegment(items, index);\n  return (selectedIds.includes(id) ? [...selectedIds] : [id]).filter((x) => {\n    const i = items.findIndex((it) => it.id === x);\n    return i >= lo && i < hi;\n  });\n}\n\n/** Would dropping `draggedIds` at `targetIndex` leave a contiguous block where it already is? */\nfunction isNoopDrop(items: readonly ReorderItem[], draggedIds: readonly string[], targetIndex: number): boolean {\n  const indices = draggedIds\n    .map((id) => items.findIndex((it) => it.id === id))\n    .filter((i) => i >= 0)\n    .sort((a, b) => a - b);\n  const contiguous =\n    indices.length > 0 &&\n    indices.every((v, i) => {\n      if (i === 0) return true;\n      const prev = indices[i - 1];\n      return prev !== undefined && v === prev + 1;\n    });\n  const first = indices[0];\n  const last = indices[indices.length - 1];\n  return contiguous\n    && first !== undefined\n    && last !== undefined\n    && targetIndex >= first\n    && targetIndex <= last + 1;\n}\n\n/**\n * Drag-to-reorder for a vertical list of rows. Dragging a row that is part of\n * the current selection drags the whole selection; dragging any other row\n * drags just that row. Locked rows can neither be dragged nor crossed by a\n * drop. A drop that would leave a contiguous block where it already is does\n * not call `onReorder`.\n *\n * The rows are the container's children, whatever they are: `ItemList` rows,\n * or the `PropertyGroup`s of a `PropertyList`. A row's `onPointerDown` can go\n * on the whole row or on a handle inside it.\n *\n * A press opens a `startThresholdDrag` on the *container*, which owns the\n * rest of the gesture: a drag that leaves the list still tracks, a release\n * anywhere still drops, and a release the window never delivered still ends\n * the drag. The container is the origin rather than the row because rows come\n * and go as the list re-renders, and a drag must outlive the row it grabbed.\n */\nexport function useReorderDragList(opts: UseReorderDragListOptions): ReorderDragHandlers {\n  const optsRef = useRef(opts);\n  optsRef.current = opts;\n  const containerRef = useRef<HTMLElement | null>(null);\n  const dragRef = useRef<ThresholdDragHandle | null>(null);\n  const [state, setState] = useState<ReorderDragState>(IDLE);\n\n  useEffect(() => () => { dragRef.current?.cancel(); }, []);\n\n  const computeTargetIndex = useCallback((clientY: number, sourceIndex: number): number => {\n    const [lo, hi] = unlockedSegment(optsRef.current.items, sourceIndex);\n    const c = containerRef.current;\n    if (!c) return lo;\n    const sel = optsRef.current.rowSelector;\n    const rows = (sel ? Array.from(c.children).filter((el) => el.matches(sel)) : Array.from(c.children)) as HTMLElement[];\n    let raw = rows.length;\n    for (let i = 0; i < rows.length; i++) {\n      const row = rows[i];\n      if (!row) continue;\n      const r = row.getBoundingClientRect();\n      if (clientY < r.bottom) { raw = i; break; }\n    }\n    return Math.max(lo, Math.min(raw, hi));\n  }, []);\n\n  const refCb = useCallback<RefCallback<HTMLElement>>((el) => {\n    containerRef.current = el;\n  }, []);\n\n  const reset = useCallback(() => {\n    dragRef.current = null;\n    setState(IDLE);\n  }, []);\n\n  const onPointerDownRow = useCallback((id: string, index: number, e: ReactPointerEvent) => {\n    const container = containerRef.current;\n    if (!container || dragRef.current) return;\n    if (isInControlWithin(e.target, e.currentTarget as Element)) return;\n\n    const mods: PressModifiers = {\n      shiftKey: e.shiftKey, ctrlKey: e.ctrlKey, metaKey: e.metaKey, altKey: e.altKey,\n    };\n    let draggedIds: string[] = [];\n    let targetIndex = 0;\n    // Where in the grabbed row the pointer went down, so the ghost keeps that point under it. The handler may sit on\n    // a handle inside the row rather than the row itself, so the row is the container's child holding it.\n    const pressed = e.currentTarget as Element;\n    const rowEl = Array.from(container.children).find((child) => child.contains(pressed)) ?? pressed;\n    const row = rowEl.getBoundingClientRect();\n    const grab = { x: e.clientX - row.left, y: e.clientY - row.top };\n    const ghostAt = (ev: { clientX: number; clientY: number }): ReorderGhost => ({\n      ids: draggedIds,\n      left: ev.clientX - grab.x,\n      top: ev.clientY - grab.y,\n      width: row.width,\n    });\n\n    dragRef.current = startThresholdDrag(e, {\n      origin: container,\n      // A locked row still opens a drag so its release reaches `onPress`, and\n      // a threshold nothing can cross is what keeps it from ever engaging.\n      threshold: optsRef.current.items[index]?.locked\n        ? Number.POSITIVE_INFINITY\n        : (optsRef.current.threshold ?? 4),\n      onActivate: (ev) => {\n        draggedIds = draggedIdsFor(optsRef.current.items, optsRef.current.selectedIds, id, index);\n        targetIndex = computeTargetIndex(ev.clientY, index);\n        setState({ draggedIds, targetIndex, ghost: ghostAt(ev) });\n      },\n      onMove: (ev) => {\n        targetIndex = computeTargetIndex(ev.clientY, index);\n        setState({ draggedIds, targetIndex, ghost: ghostAt(ev) });\n      },\n      onCommit: (ev) => {\n        const drop = computeTargetIndex(ev.clientY, index);\n        if (!isNoopDrop(optsRef.current.items, draggedIds, drop)) {\n          optsRef.current.onReorder(draggedIds, drop);\n        }\n        reset();\n      },\n      onClick: () => {\n        const { onPress } = optsRef.current;\n        if (onPress) {\n          onPress(id, mods);\n          swallowNextClick(container);\n        }\n        reset();\n      },\n      // Every cancel reason — the browser's, a lost capture, an unmount —\n      // says the gesture was interrupted rather than aimed, so the rows stay\n      // where they were.\n      onCancel: reset,\n    });\n  }, [computeTargetIndex, reset]);\n\n  const nudge = useCallback((id: string, index: number, delta: -1 | 1): boolean => {\n    const { items, selectedIds, onReorder } = optsRef.current;\n    if (items[index]?.locked) return false;\n    const ids = draggedIdsFor(items, selectedIds, id, index);\n    const at = ids.map((x) => items.findIndex((it) => it.id === x)).sort((a, b) => a - b);\n    const first = at[0];\n    const last = at[at.length - 1];\n    if (first === undefined || last === undefined) return false;\n    const [lo, hi] = unlockedSegment(items, index);\n    const target = delta < 0 ? first - 1 : last + 2;\n    if (target < lo || target > hi || isNoopDrop(items, ids, target)) return false;\n    onReorder(ids, target);\n    return true;\n  }, []);\n\n  return {\n    nudge,\n    rowProps: (id, index) => ({\n      onPointerDown: (e) => onPointerDownRow(id, index, e),\n    }),\n    containerProps: {\n      ref: refCb,\n    },\n    state,\n  };\n}\n\n/**\n * The session captured the pointer on the container, so browsers disagree on\n * where the release's click lands; it may still reach the row. `onPress` has\n * already reported this press, so that click is dropped rather than read as a\n * second one. It is dispatched in the same task as the release.\n */\nfunction swallowNextClick(container: HTMLElement): void {\n  const swallow = (e: Event) => { e.stopPropagation(); };\n  container.addEventListener('click', swallow, true);\n  setTimeout(() => { container.removeEventListener('click', swallow, true); }, 0);\n}\n"],"mappings":"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"}

package/dist/chunks/useRovingTabIndex-Bp_hYm_h.js

@@ -1,65 +0,0 @@
-import { useRef as e } from "react";
-//#region src/useRovingTabIndex.ts
-function t(e) {
-	for (let t = 0; t < e.length; t++) if (!e[t].disabled) return t;
-	return -1;
-}
-function n(e) {
-	for (let t = e.length - 1; t >= 0; t--) if (!e[t].disabled) return t;
-	return -1;
-}
-function r(e, t) {
-	let n = e.length;
-	for (let r = 1; r <= n; r++) {
-		let i = (t + r + n) % n;
-		if (!e[i].disabled) return i;
-	}
-	return t;
-}
-function i(e, t) {
-	let n = e.length;
-	for (let r = 1; r <= n; r++) {
-		let i = (t - r + n) % n;
-		if (!e[i].disabled) return i;
-	}
-	return t;
-}
-function a(a) {
-	let { items: o, itemClassName: s, onNavigate: c, onActivate: l } = a, u = e(null), d = a.tabStopIndex ?? t(o), f = (e) => {
-		let t = u.current;
-		t && t.querySelectorAll(`.${s}`)[e]?.focus();
-	};
-	return {
-		rootRef: u,
-		tabIndexFor: (e) => e === d ? 0 : -1,
-		onKeyDown: (e) => (a) => {
-			let s = -1;
-			switch (a.key) {
-				case "ArrowLeft":
-				case "ArrowUp":
-					s = i(o, e);
-					break;
-				case "ArrowRight":
-				case "ArrowDown":
-					s = r(o, e);
-					break;
-				case "Home":
-					s = t(o);
-					break;
-				case "End":
-					s = n(o);
-					break;
-				case " ":
-				case "Enter":
-					l && (a.preventDefault(), l(e));
-					return;
-				default: return;
-			}
-			s < 0 || s === e || (a.preventDefault(), c?.(s), f(s));
-		}
-	};
-}
-//#endregion
-export { a as t };
-
-//# sourceMappingURL=useRovingTabIndex-Bp_hYm_h.js.map

package/dist/chunks/useRovingTabIndex-Bp_hYm_h.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useRovingTabIndex-Bp_hYm_h.js","names":["firstEnabledIndex","i","items","lastEnabledIndex","nextEnabledIndex","k","from","prevEnabledIndex","useRovingTabIndex","options","rootRef","useRef","tabStopIndex","focusItem","root","itemClassName","index","nextIndex","e","onActivate","onNavigate"],"sources":["../../src/useRovingTabIndex.ts"],"sourcesContent":["import { useRef, type KeyboardEvent as ReactKeyboardEvent, type RefObject } from 'react';\n\n/** The only thing the hook needs to know about a bar's items: which are\n *  skipped by arrow navigation. */\nexport type RovingItem = { disabled?: boolean };\n\n/** Options for {@link useRovingTabIndex}. */\nexport type UseRovingTabIndexOptions = {\n  /** In the same order as the elements carrying `itemClassName`. */\n  items: readonly RovingItem[];\n  /** Class on the focusable element of each item, inside the container the\n   *  returned `rootRef` is attached to. Their DOM order must match `items`. */\n  itemClassName: string;\n  /** Index that carries `tabIndex=0`. Defaults to the first enabled item; a\n   *  radiogroup-style bar passes its selected index so Tab lands on the\n   *  current value. */\n  tabStopIndex?: number;\n  /** Called with the new index as arrow/Home/End focus moves, before focus\n   *  moves. This is where a selection-follows-focus bar commits the value. */\n  onNavigate?: (index: number) => void;\n  /** Space/Enter on the item at `index`. When omitted the keypress is left\n   *  alone, which on a native `<button>` produces an ordinary click. */\n  onActivate?: (index: number) => void;\n};\n\n/**\n * What {@link useRovingTabIndex} returns: a container ref plus the per-item\n * `tabIndex` and `onKeyDown` values to spread onto each item.\n */\nexport type RovingTabIndex<T extends HTMLElement = HTMLDivElement> = {\n  /** Attach to the container element that holds the items. */\n  rootRef: RefObject<T | null>;\n  /** `tabIndex` value for the item at `index`. */\n  tabIndexFor: (index: number) => 0 | -1;\n  /** `onKeyDown` for the item at `index`. */\n  onKeyDown: (index: number) => (e: ReactKeyboardEvent<HTMLElement>) => void;\n};\n\nfunction firstEnabledIndex(items: readonly RovingItem[]): number {\n  for (let i = 0; i < items.length; i++) if (!items[i].disabled) return i;\n  return -1;\n}\n\nfunction lastEnabledIndex(items: readonly RovingItem[]): number {\n  for (let i = items.length - 1; i >= 0; i--) if (!items[i].disabled) return i;\n  return -1;\n}\n\nfunction nextEnabledIndex(items: readonly RovingItem[], from: number): number {\n  const n = items.length;\n  for (let k = 1; k <= n; k++) {\n    const i = (from + k + n) % n;\n    if (!items[i].disabled) return i;\n  }\n  return from;\n}\n\nfunction prevEnabledIndex(items: readonly RovingItem[], from: number): number {\n  const n = items.length;\n  for (let k = 1; k <= n; k++) {\n    const i = (from - k + n) % n;\n    if (!items[i].disabled) return i;\n  }\n  return from;\n}\n\n/**\n * Roving tabindex for a bar of items: one item is in the tab order, and the\n * arrow keys move focus among the rest, skipping disabled ones and wrapping\n * at both ends. Home and End go to the first and last enabled item. Both axes\n * navigate, so the same bar works laid out either way.\n *\n * Backs `ButtonBar`, `OptionsBar`, and `ToggleBar`.\n *\n * **When a bar should not use this.** What decides it is the items, not who\n * owns them. A container of compound controls — a number field, a select, a\n * color field — must leave the arrow keys alone, because those controls edit\n * their own value with them; taking the arrows over would break the control\n * to navigate between controls. `ToolOptionsBar` is that case: it draws its\n * own controls from a tool's schema now rather than taking arbitrary\n * children, and a schema-drawn number field eats arrows exactly as a\n * hand-placed one did, so it keeps plain DOM tab order. A bar whose items are\n * all simple buttons is the case this hook is for.\n *\n * With every item disabled there is no tab stop and the bar drops out of the\n * tab order entirely.\n */\nexport function useRovingTabIndex<T extends HTMLElement = HTMLDivElement>(\n  options: UseRovingTabIndexOptions,\n): RovingTabIndex<T> {\n  const { items, itemClassName, onNavigate, onActivate } = options;\n  const rootRef = useRef<T | null>(null);\n\n  const tabStopIndex = options.tabStopIndex ?? firstEnabledIndex(items);\n\n  const focusItem = (index: number): void => {\n    const root = rootRef.current;\n    if (!root) return;\n    const elements = root.querySelectorAll<HTMLElement>(`.${itemClassName}`);\n    elements[index]?.focus();\n  };\n\n  const onKeyDown = (index: number) => (e: ReactKeyboardEvent<HTMLElement>): void => {\n    let nextIndex = -1;\n    switch (e.key) {\n      case 'ArrowLeft':\n      case 'ArrowUp':\n        nextIndex = prevEnabledIndex(items, index);\n        break;\n      case 'ArrowRight':\n      case 'ArrowDown':\n        nextIndex = nextEnabledIndex(items, index);\n        break;\n      case 'Home':\n        nextIndex = firstEnabledIndex(items);\n        break;\n      case 'End':\n        nextIndex = lastEnabledIndex(items);\n        break;\n      case ' ':\n      case 'Enter':\n        if (onActivate) {\n          e.preventDefault();\n          onActivate(index);\n        }\n        return;\n      default:\n        return;\n    }\n    if (nextIndex < 0 || nextIndex === index) return;\n    e.preventDefault();\n    onNavigate?.(nextIndex);\n    focusItem(nextIndex);\n  };\n\n  return {\n    rootRef,\n    tabIndexFor: (index: number) => (index === tabStopIndex ? 0 : -1),\n    onKeyDown,\n  };\n}\n"],"mappings":";;AAsCA,SAASA,EAAkB,GAAsC;CAC/D,KAAK,IAAIC,IAAI,GAAGA,IAAIC,EAAM,QAAQ,KAAK,IAAI,CAACA,EAAMD,EAAE,CAAC,UAAU,OAAOA;CACtE,OAAO;AACT;AAEA,SAASE,EAAiB,GAAsC;CAC9D,KAAK,IAAIF,IAAIC,EAAM,SAAS,GAAGD,KAAK,GAAG,KAAK,IAAI,CAACC,EAAMD,EAAE,CAAC,UAAU,OAAOA;CAC3E,OAAO;AACT;AAEA,SAASG,EAAiB,GAA8B,GAAsB;CAC5E,IAAM,IAAIF,EAAM;CAChB,KAAK,IAAIG,IAAI,GAAGA,KAAK,GAAG,KAAK;EAC3B,IAAM,KAAKC,IAAOD,IAAI,KAAK;EAC3B,IAAI,CAACH,EAAM,EAAE,CAAC,UAAU,OAAO;CACjC;CACA,OAAOI;AACT;AAEA,SAASC,EAAiB,GAA8B,GAAsB;CAC5E,IAAM,IAAIL,EAAM;CAChB,KAAK,IAAIG,IAAI,GAAGA,KAAK,GAAG,KAAK;EAC3B,IAAM,KAAKC,IAAOD,IAAI,KAAK;EAC3B,IAAI,CAACH,EAAM,EAAE,CAAC,UAAU,OAAO;CACjC;CACA,OAAOI;AACT;AAuBA,SAAgBE,EACd,GACmB;CACnB,IAAM,EAAE,UAAO,kBAAe,eAAY,kBAAeC,GACnDC,IAAUC,EAAiB,IAAI,GAE/BC,IAAeH,EAAQ,gBAAgBT,EAAkBE,CAAK,GAE9DW,KAAa,MAAwB;EACzC,IAAMC,IAAOJ,EAAQ;EACrB,AAAKI,KAELA,EADsB,iBAA8B,IAAIC,GACxD,CAAA,CAASC,EAAM,EAAE,MAAM;CACzB;CAmCA,OAAO;EACL;EACA,cAAc,MAAmBA,MAAUJ,IAAe,IAAI;EAC9D,YApCiB,OAAmB,MAA6C;GACjF,IAAIK,IAAY;GAChB,QAAQC,EAAE,KAAV;IACE,KAAK;IACL,KAAK;KACH,IAAYX,EAAiBL,GAAOc,CAAK;KACzC;IACF,KAAK;IACL,KAAK;KACH,IAAYZ,EAAiBF,GAAOc,CAAK;KACzC;IACF,KAAK;KACH,IAAYhB,EAAkBE,CAAK;KACnC;IACF,KAAK;KACH,IAAYC,EAAiBD,CAAK;KAClC;IACF,KAAK;IACL,KAAK;KACH,AAAIiB,MACFD,EAAE,eAAe,GACjBC,EAAWH,CAAK;KAElB;IACF,SACE;GACJ;GACA,AAAIC,IAAY,KAAKA,MAAcD,MACnCE,EAAE,eAAe,GACjBE,IAAaH,CAAS,GACtBJ,EAAUI,CAAS;EACrB;CAMA;AACF"}

package/dist/components/DragHandleGlyph/DragHandleGlyph.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"DragHandleGlyph.d.ts","sourceRoot":"","sources":["../../../src/components/DragHandleGlyph/DragHandleGlyph.tsx"],"names":[],"mappings":"AAAA,qCAAqC;AACrC,MAAM,WAAW,oBAAoB;IACnC,sDAAsD;IACtD,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;;0DAI0D;AAC1D,wBAAgB,eAAe,CAAC,EAAE,IAAS,EAAE,EAAE,oBAAoB,+BAiBlE"}

package/dist/components/DragHandleGlyph/index.d.ts

@@ -1,3 +0,0 @@
-export type { DragHandleGlyphProps } from './DragHandleGlyph';
-export { DragHandleGlyph } from './DragHandleGlyph';
-//# sourceMappingURL=index.d.ts.map

package/dist/components/DragHandleGlyph/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/DragHandleGlyph/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/components/DragHandleGlyph/index.js

@@ -1,2 +0,0 @@
-import { t as e } from "../../chunks/DragHandleGlyph-Dr7Fgo0I.js";
-export { e as DragHandleGlyph };

package/dist/format/number.d.ts

@@ -1,56 +0,0 @@
-/**
- * Display-formatter for numbers. Use this anywhere a number is shown to
- * a user. The whole point: negative values get prefixed with the real
- * MINUS SIGN (U+2212) instead of the ASCII HYPHEN-MINUS (U+002D) that
- * `toLocaleString` and template literals produce by default.
- *
- * U+2212 is the same visual width as `+` and reads as a sign rather
- * than a hyphen — columns of signed numbers align cleanly and the
- * glyph doesn't get confused with a bullet or list dash.
- */
-export declare const MINUS_SIGN = "\u2212";
-/**
- * Formats a number for display, substituting {@link MINUS_SIGN} for the ASCII
- * hyphen `toLocaleString` emits. Non-finite values stringify as-is.
- */
-export declare function formatNumber(value: number, options?: Intl.NumberFormatOptions): string;
-/**
- * Parses a string that may carry {@link MINUS_SIGN} in place of the ASCII
- * hyphen. The inverse of {@link formatNumber} for any editing surface that
- * renders its value through it and reads the edited text back.
- */
-export declare function parseSignedNumber(text: string): number;
-/**
- * Formats a number the way a `compact` readout shows it: below 1,000 at
- * `decimals` places, from 1,000 up at three significant figures with a magnitude
- * suffix (`40.0K`, `294K`, `2.00M`), so the readout holds one width whatever the
- * value. Always `en-US`, so {@link parseNumber} reads it back.
- */
-export declare function formatCompact(value: number, decimals?: number): string;
-/**
- * Reads a typed number: anything {@link parseSignedNumber} reads, plus
- * thousands commas in the `40,000` shape and a `k`/`m`/`b`/`t` suffix in either
- * case (`2.5m` is 2,500,000). Empty text is NaN rather than zero.
- *
- * Given `units` — a suffix mapped to the factor it scales by — a trailing unit
- * name is read first: the longest match wins, exact case before any case, and
- * a unit beats a magnitude suffix, so with `m` accepted `2m` is `2 * units.m`.
- */
-export declare function parseNumber(text: string, units?: Readonly<UnitTable>): number;
-/** One unit's conversion into the shown unit: a bare factor, or a scale that
- *  also moves zero. Structurally the kit's `UnitEntry`, kept local so this
- *  formatting helper stays free of the scene vocabulary. */
-export type UnitTableEntry = number | {
-    factor: number;
-    offset?: number;
-};
-/** Suffixes a person may type, each mapped to its conversion. */
-export type UnitTable = Record<string, UnitTableEntry>;
-/**
- * Formats a zoom factor for display. Below 2x a percentage reads naturally;
- * past it the numbers get long and a multiplier is what people say out loud,
- * so 250% shows as `2.5x`. Past 100x a tenth is noise, so the decimal is
- * dropped and thousands are grouped: `1009.74` reads as `1,010x`.
- */
-export declare function formatZoom(zoom: number): string;
-//# sourceMappingURL=number.d.ts.map

package/dist/format/number.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"number.d.ts","sourceRoot":"","sources":["../../src/format/number.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,eAAO,MAAM,UAAU,WAAM,CAAC;AAE9B;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,CAAC,mBAAmB,GAAG,MAAM,CAKtF;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEtD;AAKD;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,SAAI,GAAG,MAAM,CAOjE;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,QAAQ,CAAC,SAAS,CAAC,GAAG,MAAM,CAkB7E;AAED;;4DAE4D;AAC5D,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAC1E,iEAAiE;AACjE,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;AAoEvD;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAK/C"}

package/dist/icons/ShapeKindIcon.d.ts

@@ -1,10 +0,0 @@
-import { type IconProps, type ShapeKind } from '@weasel-js/core';
-export interface ShapeKindIconProps extends IconProps {
-    /** A built-in shape kind. Any other string draws `UnknownIcon`, so a
-     *  consumer-defined kind still gets a glyph. */
-    kind: ShapeKind | (string & {});
-}
-/** The glyph for a shape kind — the same one its insertion tool shows, so a
- *  row in a layer list or inspector matches the palette that made it. */
-export declare function ShapeKindIcon({ kind, ...props }: ShapeKindIconProps): import("react").JSX.Element;
-//# sourceMappingURL=ShapeKindIcon.d.ts.map

package/dist/icons/ShapeKindIcon.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ShapeKindIcon.d.ts","sourceRoot":"","sources":["../../src/icons/ShapeKindIcon.tsx"],"names":[],"mappings":"AACA,OAAO,EAGL,KAAK,SAAS,EAAE,KAAK,SAAS,EAC/B,MAAM,iBAAiB,CAAC;AAezB,MAAM,WAAW,kBAAmB,SAAQ,SAAS;IACnD;oDACgD;IAChD,IAAI,EAAE,SAAS,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC;CACjC;AAED;yEACyE;AACzE,wBAAgB,aAAa,CAAC,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE,EAAE,kBAAkB,+BAGnE"}