@vielzeug/orbit 1.1.4 → 2.0.0

package/dist/types.d.ts

@@ -100,11 +100,6 @@ export interface MiddlewareResult {
     reset?: MiddlewareReset;
 }
 export type Middleware = (state: MiddlewareState) => MiddlewareResult | void;
-/**
- * A middleware branded with the key it writes to `middlewareData`.
- * Built-in middleware return this type. Custom middleware can cast to it if needed.
- */
-export type TypedMiddleware<K extends string, D> = Middleware & {};
 export interface ComputePositionResult {
     x: number;
     y: number;
@@ -112,8 +107,8 @@ export interface ComputePositionResult {
     middlewareData: MiddlewareData;
 }
 export interface ComputePositionOptions {
-    /** Middleware pipeline to run. Falsy entries are ignored. */
-    middleware?: Array<Middleware | null | undefined | false>;
+    /** Middleware pipeline to run in the supplied order. */
+    middleware?: readonly Middleware[];
     /** Initial placement. Defaults to `'bottom'`. */
     placement?: Placement;
     /**
@@ -135,28 +130,6 @@ export interface ComputePositionOptions {
      */
     padding?: Padding;
 }
-/**
- * Handle returned by `float()`.
- *
- * - `dispose()` — removes all event listeners and observers. Always call this on teardown.
- * - `update()` — manually trigger a position recalculation.
- * - `getPosition()` — returns the most recently computed position.
- *   - When `autoUpdate: false`, the position is computed synchronously during `float()`, so
- *     `getPosition()` is **never `null`** immediately after `float()` returns.
- *   - When using the `autoUpdate` loop (default), `getPosition()` returns `null` only before
- *     the very first update fires, which happens synchronously on construction.
- *   - Always returns `null` in SSR environments (via `@vielzeug/orbit/ssr`).
- */
-export interface FloatHandle {
-    /** `AbortSignal` aborted when `dispose()` is called. Use to tie external lifetimes to this handle. */
-    readonly disposalSignal: AbortSignal;
-    dispose(): void;
-    /** `true` after `dispose()` has been called. */
-    readonly disposed: boolean;
-    getPosition(): ComputePositionResult | null;
-    update(): void;
-    [Symbol.dispose](): void;
-}
 export interface DetectOverflowOptions {
     /** Boundary element or rect. Defaults to the visual viewport. */
     boundary?: Element | Rect;

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,wDAAwD;AAExD,MAAM,MAAM,IAAI,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,CAAC;AACvD,MAAM,MAAM,SAAS,GAAG,OAAO,GAAG,KAAK,CAAC;AACxC,MAAM,MAAM,SAAS,GAAG,IAAI,GAAG,GAAG,IAAI,IAAI,SAAS,EAAE,CAAC;AAEtD,MAAM,WAAW,IAAI;IACnB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,gBAAgB;IAC/B,qBAAqB,EAAE,MAAM,OAAO,GAAG,IAAI,CAAC;IAC5C,cAAc,CAAC,EAAE,MAAM,WAAW,GAAG,OAAO,EAAE,CAAC;CAChD;AAED,MAAM,MAAM,gBAAgB,GAAG,OAAO,GAAG,gBAAgB,CAAC;AAE1D,MAAM,WAAW,UAAU;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,MAAM,OAAO,GAAG,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AAInD,MAAM,WAAW,SAAS;IACxB,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,YAAY,EAAE,MAAM,CAAC;IACrB,0HAA0H;IAC1H,WAAW,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,WAAW,QAAQ;IACvB,6FAA6F;IAC7F,iBAAiB,EAAE,SAAS,EAAE,CAAC;CAChC;AAED,MAAM,WAAW,SAAS;IACxB,8CAA8C;IAC9C,CAAC,EAAE,MAAM,CAAC;IACV,8CAA8C;IAC9C,CAAC,EAAE,MAAM,CAAC;CACX;AAED,MAAM,WAAW,QAAQ;IACvB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,cAAc,CAAC,EAAE,UAAU,CAAC;IAC5B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,sBAAsB,CAAC,EAAE,UAAU,CAAC;CACrC;AAED,MAAM,WAAW,QAAQ;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB,IAAI,CAAC,EAAE,QAAQ,CAAC;IAChB,IAAI,CAAC,EAAE,QAAQ,CAAC;IAChB,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB,IAAI,CAAC,EAAE,QAAQ,CAAC;IAChB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAID,MAAM,WAAW,eAAe;IAC9B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,gBAAgB,EAAE,SAAS,CAAC;IAC5B,SAAS,EAAE,SAAS,CAAC;IACrB,KAAK,EAAE;QAAE,QAAQ,EAAE,IAAI,CAAC;QAAC,SAAS,EAAE,IAAI,CAAA;KAAE,CAAC;IAC3C,QAAQ,EAAE;QAAE,QAAQ,EAAE,WAAW,CAAC;QAAC,SAAS,EAAE,gBAAgB,CAAA;KAAE,CAAC;IACjE,cAAc,EAAE,cAAc,CAAC;IAC/B,kGAAkG;IAClG,QAAQ,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAC1B,gGAAgG;IAChG,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;;;;;;;;;GAUG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,qFAAqF;IACrF,KAAK,CAAC,EAAE,eAAe,CAAC,OAAO,CAAC,CAAC;IACjC,8EAA8E;IAC9E,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,CAAC;AAEF,MAAM,WAAW,gBAAgB;IAC/B,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,IAAI,CAAC,EAAE,cAAc,CAAC;IACtB,KAAK,CAAC,EAAE,eAAe,CAAC;CACzB;AAED,MAAM,MAAM,UAAU,GAAG,CAAC,KAAK,EAAE,eAAe,KAAK,gBAAgB,GAAG,IAAI,CAAC;AAE7E;;;GAGG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,IAAI,UAAU,GAAG,EAG/D,CAAC;AAIF,MAAM,WAAW,qBAAqB;IACpC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,SAAS,EAAE,SAAS,CAAC;IACrB,cAAc,EAAE,cAAc,CAAC;CAChC;AAED,MAAM,WAAW,sBAAsB;IACrC,6DAA6D;IAC7D,UAAU,CAAC,EAAE,KAAK,CAAC,UAAU,GAAG,IAAI,GAAG,SAAS,GAAG,KAAK,CAAC,CAAC;IAC1D,iDAAiD;IACjD,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IACjC;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAC1B;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,WAAW;IAC1B,sGAAsG;IACtG,QAAQ,CAAC,cAAc,EAAE,WAAW,CAAC;IACrC,OAAO,IAAI,IAAI,CAAC;IAChB,gDAAgD;IAChD,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,WAAW,IAAI,qBAAqB,GAAG,IAAI,CAAC;IAC5C,MAAM,IAAI,IAAI,CAAC;IACf,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC;CAC1B;AAED,MAAM,WAAW,qBAAqB;IACpC,iEAAiE;IACjE,QAAQ,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAC1B,gFAAgF;IAChF,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/utils.cjs

@@ -1,2 +1,2 @@
-const e=require("./errors.cjs");require("@vielzeug/arsenal/math");var t={bottom:`top`,left:`right`,right:`left`,top:`bottom`};function n(e){return e.split(`-`)[0]}function r(e){return e.split(`-`)[1]??null}function i(e,t){return t?`${e}-${t}`:e}function a({height:e,width:t,x:n,y:r}){return{height:e,width:t,x:n,y:r}}function o(e=0){return typeof e==`number`?{bottom:e,left:e,right:e,top:e}:{bottom:e.bottom??0,left:e.left??0,right:e.right??0,top:e.top??0}}function s(e){return typeof Element<`u`&&e instanceof Element}function c(e){return e.assignedSlot?e.assignedSlot:e.parentElement??(e.getRootNode()instanceof ShadowRoot?e.getRootNode().host:null)}var l=[[`arrow`,`flip`],[`arrow`,`shift`],[`arrow`,`autoPlacement`],[`flip`,`inline`],[`shift`,`inline`],[`autoPlacement`,`inline`],[`size`,`flip`],[`size`,`autoPlacement`]];function u(t){for(let[n,r]of l){let i=t.indexOf(n),a=t.indexOf(r);if(i!==-1&&a!==-1&&i<a)throw new e.OrbitConfigError(`"${n}" must come after "${r}" in the middleware pipeline. Recommended order: inline → offset → flip/autoPlacement → shift → size → arrow.`)}if(t.includes(`flip`)&&t.includes(`autoPlacement`))throw new e.OrbitConfigError(`use either flip() or autoPlacement() in the middleware pipeline, not both.`)}var d=Symbol.for(`@vielzeug/orbit/name`);function f(e,t){return e[d]=t,e}function p(e,t,n,r){return e===`start`?t:e===`end`?t+n-r:t+(n-r)/2}function m(e,t,i){let a=n(e),o=r(e);switch(a){case`bottom`:return{x:p(o,t.x,t.width,i.width),y:t.y+t.height};case`left`:return{x:t.x-i.width,y:p(o,t.y,t.height,i.height)};case`right`:return{x:t.x+t.width,y:p(o,t.y,t.height,i.height)};case`top`:return{x:p(o,t.x,t.width,i.width),y:t.y-i.height}}}exports.MIDDLEWARE_NAME=d,exports.MIDDLEWARE_ORDER_RULES=l,exports.OPPOSITE=t,exports.baseCoords=m,exports.flatTreeParent=c,exports.getAlignment=r,exports.getSide=n,exports.isElement=s,exports.tagMiddleware=f,exports.toRect=a,exports.toSideObject=o,exports.validateMiddlewareNames=u,exports.withPlacement=i;
+function e(e,t,n){return Math.min(Math.max(e,t),n)}var t={bottom:`top`,left:`right`,right:`left`,top:`bottom`};function n(e){return e.split(`-`)[0]}function r(e){return e.split(`-`)[1]??null}function i(e,t){return t?`${e}-${t}`:e}function a({height:e,width:t,x:n,y:r}){return{height:e,width:t,x:n,y:r}}function o(e=0){return typeof e==`number`?{bottom:e,left:e,right:e,top:e}:{bottom:e.bottom??0,left:e.left??0,right:e.right??0,top:e.top??0}}function s(e){return typeof Element<`u`&&e instanceof Element}function c(e){return e.assignedSlot?e.assignedSlot:e.parentElement??(e.getRootNode()instanceof ShadowRoot?e.getRootNode().host:null)}function l(e,t,n,r){return e===`start`?t:e===`end`?t+n-r:t+(n-r)/2}function u(e,t,i){let a=n(e),o=r(e);switch(a){case`bottom`:return{x:l(o,t.x,t.width,i.width),y:t.y+t.height};case`left`:return{x:t.x-i.width,y:l(o,t.y,t.height,i.height)};case`right`:return{x:t.x+t.width,y:l(o,t.y,t.height,i.height)};case`top`:return{x:l(o,t.x,t.width,i.width),y:t.y-i.height}}}exports.OPPOSITE=t,exports.baseCoords=u,exports.clamp=e,exports.flatTreeParent=c,exports.getAlignment=r,exports.getSide=n,exports.isElement=s,exports.toRect=a,exports.toSideObject=o,exports.withPlacement=i;
 //# sourceMappingURL=utils.cjs.map

package/dist/utils.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"utils.cjs","names":[],"sources":["../src/utils.ts"],"sourcesContent":["import { clamp } from '@vielzeug/arsenal/math';\n\nimport type { Alignment, Middleware, Padding, Placement, Rect, Side, SideObject, TypedMiddleware } from './types';\n\nimport { OrbitConfigError } from './errors';\n\nexport { clamp };\n\nexport const OPPOSITE: Record<Side, Side> = { bottom: 'top', left: 'right', right: 'left', top: 'bottom' };\n\n/** Returns the primary side of a placement (`'top' | 'bottom' | 'left' | 'right'`). */\nexport function getSide(p: Placement): Side {\n  return p.split('-')[0] as Side;\n}\n\n/** Returns the alignment of a placement (`'start' | 'end'`), or `null` for center placements. */\nexport function getAlignment(p: Placement): Alignment | null {\n  return (p.split('-')[1] as Alignment) ?? null;\n}\n\n/** @internal */\nexport function withPlacement(side: Side, align: Alignment | null): Placement {\n  return (align ? `${side}-${align}` : side) as Placement;\n}\n\n/** @internal */\nexport function toRect({ height, width, x, y }: DOMRect | Rect): Rect {\n  return { height, width, x, y };\n}\n\n/** @internal */\nexport function toSideObject(padding: Padding = 0): SideObject {\n  if (typeof padding === 'number') {\n    return { bottom: padding, left: padding, right: padding, top: padding };\n  }\n\n  return {\n    bottom: padding.bottom ?? 0,\n    left: padding.left ?? 0,\n    right: padding.right ?? 0,\n    top: padding.top ?? 0,\n  };\n}\n\n/** @internal */\nexport function isElement(value: unknown): value is Element {\n  return typeof Element !== 'undefined' && value instanceof Element;\n}\n\n/**\n * Returns `node`'s parent in the flat (rendering) tree — the tree CSS layout, paint, and\n * containing-block rules actually walk, which is *not* the same as light-DOM `parentElement`:\n *\n * - If `node` is itself distributed into a `<slot>` (`node.assignedSlot` is set), its rendered\n *   parent is that `<slot>`, which lives inside the shadow tree that projects it — not wherever\n *   `node.parentElement` points in the light DOM. Skipping this check would walk straight past\n *   the shadow host and out into *its* light-DOM ancestors, missing every ancestor between the\n *   `<slot>` and the shadow root (a dialog's `.panel`, say) entirely.\n * - Otherwise, falls back to `parentElement`, or — once that's exhausted at a shadow root\n *   boundary — the shadow root's host, so the walk continues past shadow boundaries instead of\n *   stopping there.\n *\n * `null` once it reaches a true root.\n * @internal\n */\nexport function flatTreeParent(node: Element): Element | null {\n  if (node.assignedSlot) return node.assignedSlot;\n\n  return (\n    node.parentElement ?? (node.getRootNode() instanceof ShadowRoot ? (node.getRootNode() as ShadowRoot).host : null)\n  );\n}\n\n// ── Middleware helpers ────────────────────────────────────────────────────────\n\n/**\n * Ordering rules for dev-mode middleware validation.\n * Each tuple is `[mustFollow, mustPrecede]` — `mustFollow` must appear **after** `mustPrecede`\n * in the pipeline. Validation throws if `mustFollow` is found at a lower index than `mustPrecede`.\n * @internal\n */\nexport const MIDDLEWARE_ORDER_RULES: Array<[mustFollow: string, mustPrecede: string]> = [\n  ['arrow', 'flip'],\n  ['arrow', 'shift'],\n  ['arrow', 'autoPlacement'],\n  ['flip', 'inline'],\n  ['shift', 'inline'],\n  ['autoPlacement', 'inline'],\n  ['size', 'flip'],\n  ['size', 'autoPlacement'],\n];\n\n/**\n * Validates a list of middleware names for known-bad orderings.\n * Throws a descriptive error in dev mode if an invalid ordering is detected.\n * @internal\n */\nexport function validateMiddlewareNames(names: Array<string | null>): void {\n  for (const [mustFollow, mustPrecede] of MIDDLEWARE_ORDER_RULES) {\n    const followIdx = names.indexOf(mustFollow);\n    const precedeIdx = names.indexOf(mustPrecede);\n\n    if (followIdx !== -1 && precedeIdx !== -1 && followIdx < precedeIdx) {\n      throw new OrbitConfigError(\n        `\"${mustFollow}\" must come after \"${mustPrecede}\" in the middleware pipeline. ` +\n          `Recommended order: inline → offset → flip/autoPlacement → shift → size → arrow.`,\n      );\n    }\n  }\n\n  if (names.includes('flip') && names.includes('autoPlacement')) {\n    throw new OrbitConfigError('use either flip() or autoPlacement() in the middleware pipeline, not both.');\n  }\n}\n\n/**\n * Unique symbol used to tag middleware with a name for dev-mode ordering validation.\n * Using a Symbol avoids collisions with any `__name` property set by transpilers or wrappers.\n * @internal\n */\nexport const MIDDLEWARE_NAME = Symbol.for('@vielzeug/orbit/name');\n\n/**\n * Tags a middleware function with a name for dev-mode ordering validation and brands it\n * as a `TypedMiddleware<K, D>` for compile-time `middlewareData` inference.\n * @internal\n */\nexport function tagMiddleware<K extends string, D, F extends Middleware>(fn: F, name: K): F & TypedMiddleware<K, D> {\n  (fn as Record<symbol, unknown>)[MIDDLEWARE_NAME] = name;\n\n  return fn as F & TypedMiddleware<K, D>;\n}\n\n// ── Geometry ──────────────────────────────────────────────────────────────────\n\nfunction alignedOffset(align: Alignment | null, refStart: number, refSize: number, floatSize: number): number {\n  if (align === 'start') return refStart;\n\n  if (align === 'end') return refStart + refSize - floatSize;\n\n  return refStart + (refSize - floatSize) / 2;\n}\n\n/**\n * Computes the base (un-shifted) x/y coordinates for a floating element\n * given the placement and the reference/floating rects.\n * @internal\n */\nexport function baseCoords(placement: Placement, ref: Rect, float: Rect): { x: number; y: number } {\n  const side = getSide(placement);\n  const align = getAlignment(placement);\n\n  switch (side) {\n    case 'bottom':\n      return { x: alignedOffset(align, ref.x, ref.width, float.width), y: ref.y + ref.height };\n    case 'left':\n      return { x: ref.x - float.width, y: alignedOffset(align, ref.y, ref.height, float.height) };\n    case 'right':\n      return { x: ref.x + ref.width, y: alignedOffset(align, ref.y, ref.height, float.height) };\n    case 'top':\n      return { x: alignedOffset(align, ref.x, ref.width, float.width), y: ref.y - float.height };\n  }\n}\n"],"mappings":"kEAQA,IAAa,EAA+B,CAAE,OAAQ,MAAO,KAAM,QAAS,MAAO,OAAQ,IAAK,QAAS,EAGzG,SAAgB,EAAQ,EAAoB,CAC1C,OAAO,EAAE,MAAM,GAAG,CAAC,CAAC,EACtB,CAGA,SAAgB,EAAa,EAAgC,CAC3D,OAAQ,EAAE,MAAM,GAAG,CAAC,CAAC,IAAoB,IAC3C,CAGA,SAAgB,EAAc,EAAY,EAAoC,CAC5E,OAAQ,EAAQ,GAAG,EAAK,GAAG,IAAU,CACvC,CAGA,SAAgB,EAAO,CAAE,SAAQ,QAAO,IAAG,KAA2B,CACpE,MAAO,CAAE,SAAQ,QAAO,IAAG,GAAE,CAC/B,CAGA,SAAgB,EAAa,EAAmB,EAAe,CAK7D,OAJI,OAAO,GAAY,SACd,CAAE,OAAQ,EAAS,KAAM,EAAS,MAAO,EAAS,IAAK,CAAQ,EAGjE,CACL,OAAQ,EAAQ,QAAU,EAC1B,KAAM,EAAQ,MAAQ,EACtB,MAAO,EAAQ,OAAS,EACxB,IAAK,EAAQ,KAAO,CACtB,CACF,CAGA,SAAgB,EAAU,EAAkC,CAC1D,OAAO,OAAO,QAAY,KAAe,aAAiB,OAC5D,CAkBA,SAAgB,EAAe,EAA+B,CAG5D,OAFI,EAAK,aAAqB,EAAK,aAGjC,EAAK,gBAAkB,EAAK,YAAY,YAAa,WAAc,EAAK,YAAY,CAAC,CAAgB,KAAO,KAEhH,CAUA,IAAa,EAA2E,CACtF,CAAC,QAAS,MAAM,EAChB,CAAC,QAAS,OAAO,EACjB,CAAC,QAAS,eAAe,EACzB,CAAC,OAAQ,QAAQ,EACjB,CAAC,QAAS,QAAQ,EAClB,CAAC,gBAAiB,QAAQ,EAC1B,CAAC,OAAQ,MAAM,EACf,CAAC,OAAQ,eAAe,CAC1B,EAOA,SAAgB,EAAwB,EAAmC,CACzE,IAAK,GAAM,CAAC,EAAY,KAAgB,EAAwB,CAC9D,IAAM,EAAY,EAAM,QAAQ,CAAU,EACpC,EAAa,EAAM,QAAQ,CAAW,EAE5C,GAAI,IAAc,IAAM,IAAe,IAAM,EAAY,EACvD,MAAM,IAAI,EAAA,iBACR,IAAI,EAAW,qBAAqB,EAAY,8GAElD,CAEJ,CAEA,GAAI,EAAM,SAAS,MAAM,GAAK,EAAM,SAAS,eAAe,EAC1D,MAAM,IAAI,EAAA,iBAAiB,4EAA4E,CAE3G,CAOA,IAAa,EAAkB,OAAO,IAAI,sBAAsB,EAOhE,SAAgB,EAAyD,EAAO,EAAoC,CAGlH,MAFA,GAAgC,GAAmB,EAE5C,CACT,CAIA,SAAS,EAAc,EAAyB,EAAkB,EAAiB,EAA2B,CAK5G,OAJI,IAAU,QAAgB,EAE1B,IAAU,MAAc,EAAW,EAAU,EAE1C,GAAY,EAAU,GAAa,CAC5C,CAOA,SAAgB,EAAW,EAAsB,EAAW,EAAuC,CACjG,IAAM,EAAO,EAAQ,CAAS,EACxB,EAAQ,EAAa,CAAS,EAEpC,OAAQ,EAAR,CACE,IAAK,SACH,MAAO,CAAE,EAAG,EAAc,EAAO,EAAI,EAAG,EAAI,MAAO,EAAM,KAAK,EAAG,EAAG,EAAI,EAAI,EAAI,MAAO,EACzF,IAAK,OACH,MAAO,CAAE,EAAG,EAAI,EAAI,EAAM,MAAO,EAAG,EAAc,EAAO,EAAI,EAAG,EAAI,OAAQ,EAAM,MAAM,CAAE,EAC5F,IAAK,QACH,MAAO,CAAE,EAAG,EAAI,EAAI,EAAI,MAAO,EAAG,EAAc,EAAO,EAAI,EAAG,EAAI,OAAQ,EAAM,MAAM,CAAE,EAC1F,IAAK,MACH,MAAO,CAAE,EAAG,EAAc,EAAO,EAAI,EAAG,EAAI,MAAO,EAAM,KAAK,EAAG,EAAG,EAAI,EAAI,EAAM,MAAO,CAC7F,CACF"}
+{"version":3,"file":"utils.cjs","names":[],"sources":["../src/utils.ts"],"sourcesContent":["import type { Alignment, Padding, Placement, Rect, Side, SideObject } from './types';\n\nexport function clamp(value: number, min: number, max: number): number {\n  return Math.min(Math.max(value, min), max);\n}\n\nexport const OPPOSITE: Record<Side, Side> = { bottom: 'top', left: 'right', right: 'left', top: 'bottom' };\n\n/** Returns the primary side of a placement (`'top' | 'bottom' | 'left' | 'right'`). */\nexport function getSide(p: Placement): Side {\n  return p.split('-')[0] as Side;\n}\n\n/** Returns the alignment of a placement (`'start' | 'end'`), or `null` for center placements. */\nexport function getAlignment(p: Placement): Alignment | null {\n  return (p.split('-')[1] as Alignment) ?? null;\n}\n\n/** @internal */\nexport function withPlacement(side: Side, align: Alignment | null): Placement {\n  return (align ? `${side}-${align}` : side) as Placement;\n}\n\n/** @internal */\nexport function toRect({ height, width, x, y }: DOMRect | Rect): Rect {\n  return { height, width, x, y };\n}\n\n/** @internal */\nexport function toSideObject(padding: Padding = 0): SideObject {\n  if (typeof padding === 'number') {\n    return { bottom: padding, left: padding, right: padding, top: padding };\n  }\n\n  return {\n    bottom: padding.bottom ?? 0,\n    left: padding.left ?? 0,\n    right: padding.right ?? 0,\n    top: padding.top ?? 0,\n  };\n}\n\n/** @internal */\nexport function isElement(value: unknown): value is Element {\n  return typeof Element !== 'undefined' && value instanceof Element;\n}\n\n/**\n * Returns `node`'s parent in the flat (rendering) tree — the tree CSS layout, paint, and\n * containing-block rules actually walk, which is *not* the same as light-DOM `parentElement`:\n *\n * - If `node` is itself distributed into a `<slot>` (`node.assignedSlot` is set), its rendered\n *   parent is that `<slot>`, which lives inside the shadow tree that projects it — not wherever\n *   `node.parentElement` points in the light DOM. Skipping this check would walk straight past\n *   the shadow host and out into *its* light-DOM ancestors, missing every ancestor between the\n *   `<slot>` and the shadow root (a dialog's `.panel`, say) entirely.\n * - Otherwise, falls back to `parentElement`, or — once that's exhausted at a shadow root\n *   boundary — the shadow root's host, so the walk continues past shadow boundaries instead of\n *   stopping there.\n *\n * `null` once it reaches a true root.\n * @internal\n */\nexport function flatTreeParent(node: Element): Element | null {\n  if (node.assignedSlot) return node.assignedSlot;\n\n  return (\n    node.parentElement ?? (node.getRootNode() instanceof ShadowRoot ? (node.getRootNode() as ShadowRoot).host : null)\n  );\n}\n\n// ── Geometry ──────────────────────────────────────────────────────────────────\n\nfunction alignedOffset(align: Alignment | null, refStart: number, refSize: number, floatSize: number): number {\n  if (align === 'start') return refStart;\n\n  if (align === 'end') return refStart + refSize - floatSize;\n\n  return refStart + (refSize - floatSize) / 2;\n}\n\n/**\n * Computes the base (un-shifted) x/y coordinates for a floating element\n * given the placement and the reference/floating rects.\n * @internal\n */\nexport function baseCoords(placement: Placement, ref: Rect, float: Rect): { x: number; y: number } {\n  const side = getSide(placement);\n  const align = getAlignment(placement);\n\n  switch (side) {\n    case 'bottom':\n      return { x: alignedOffset(align, ref.x, ref.width, float.width), y: ref.y + ref.height };\n    case 'left':\n      return { x: ref.x - float.width, y: alignedOffset(align, ref.y, ref.height, float.height) };\n    case 'right':\n      return { x: ref.x + ref.width, y: alignedOffset(align, ref.y, ref.height, float.height) };\n    case 'top':\n      return { x: alignedOffset(align, ref.x, ref.width, float.width), y: ref.y - float.height };\n  }\n}\n"],"mappings":"AAEA,SAAgB,EAAM,EAAe,EAAa,EAAqB,CACrE,OAAO,KAAK,IAAI,KAAK,IAAI,EAAO,CAAG,EAAG,CAAG,CAC3C,CAEA,IAAa,EAA+B,CAAE,OAAQ,MAAO,KAAM,QAAS,MAAO,OAAQ,IAAK,QAAS,EAGzG,SAAgB,EAAQ,EAAoB,CAC1C,OAAO,EAAE,MAAM,GAAG,CAAC,CAAC,EACtB,CAGA,SAAgB,EAAa,EAAgC,CAC3D,OAAQ,EAAE,MAAM,GAAG,CAAC,CAAC,IAAoB,IAC3C,CAGA,SAAgB,EAAc,EAAY,EAAoC,CAC5E,OAAQ,EAAQ,GAAG,EAAK,GAAG,IAAU,CACvC,CAGA,SAAgB,EAAO,CAAE,SAAQ,QAAO,IAAG,KAA2B,CACpE,MAAO,CAAE,SAAQ,QAAO,IAAG,GAAE,CAC/B,CAGA,SAAgB,EAAa,EAAmB,EAAe,CAK7D,OAJI,OAAO,GAAY,SACd,CAAE,OAAQ,EAAS,KAAM,EAAS,MAAO,EAAS,IAAK,CAAQ,EAGjE,CACL,OAAQ,EAAQ,QAAU,EAC1B,KAAM,EAAQ,MAAQ,EACtB,MAAO,EAAQ,OAAS,EACxB,IAAK,EAAQ,KAAO,CACtB,CACF,CAGA,SAAgB,EAAU,EAAkC,CAC1D,OAAO,OAAO,QAAY,KAAe,aAAiB,OAC5D,CAkBA,SAAgB,EAAe,EAA+B,CAG5D,OAFI,EAAK,aAAqB,EAAK,aAGjC,EAAK,gBAAkB,EAAK,YAAY,YAAa,WAAc,EAAK,YAAY,CAAC,CAAgB,KAAO,KAEhH,CAIA,SAAS,EAAc,EAAyB,EAAkB,EAAiB,EAA2B,CAK5G,OAJI,IAAU,QAAgB,EAE1B,IAAU,MAAc,EAAW,EAAU,EAE1C,GAAY,EAAU,GAAa,CAC5C,CAOA,SAAgB,EAAW,EAAsB,EAAW,EAAuC,CACjG,IAAM,EAAO,EAAQ,CAAS,EACxB,EAAQ,EAAa,CAAS,EAEpC,OAAQ,EAAR,CACE,IAAK,SACH,MAAO,CAAE,EAAG,EAAc,EAAO,EAAI,EAAG,EAAI,MAAO,EAAM,KAAK,EAAG,EAAG,EAAI,EAAI,EAAI,MAAO,EACzF,IAAK,OACH,MAAO,CAAE,EAAG,EAAI,EAAI,EAAM,MAAO,EAAG,EAAc,EAAO,EAAI,EAAG,EAAI,OAAQ,EAAM,MAAM,CAAE,EAC5F,IAAK,QACH,MAAO,CAAE,EAAG,EAAI,EAAI,EAAI,MAAO,EAAG,EAAc,EAAO,EAAI,EAAG,EAAI,OAAQ,EAAM,MAAM,CAAE,EAC1F,IAAK,MACH,MAAO,CAAE,EAAG,EAAc,EAAO,EAAI,EAAG,EAAI,MAAO,EAAM,KAAK,EAAG,EAAG,EAAI,EAAI,EAAM,MAAO,CAC7F,CACF"}

package/dist/utils.d.ts

@@ -1,6 +1,5 @@
-import { clamp } from '@vielzeug/arsenal/math';
 import type { Alignment, Placement, Side } from './types';
-export { clamp };
+export declare function clamp(value: number, min: number, max: number): number;
 export declare const OPPOSITE: Record<Side, Side>;
 /** Returns the primary side of a placement (`'top' | 'bottom' | 'left' | 'right'`). */
 export declare function getSide(p: Placement): Side;

package/dist/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAC;AAE/C,OAAO,KAAK,EAAE,SAAS,EAAuB,SAAS,EAAQ,IAAI,EAA+B,MAAM,SAAS,CAAC;AAIlH,OAAO,EAAE,KAAK,EAAE,CAAC;AAEjB,eAAO,MAAM,QAAQ,EAAE,MAAM,CAAC,IAAI,EAAE,IAAI,CAAkE,CAAC;AAE3G,uFAAuF;AACvF,wBAAgB,OAAO,CAAC,CAAC,EAAE,SAAS,GAAG,IAAI,CAE1C;AAED,iGAAiG;AACjG,wBAAgB,YAAY,CAAC,CAAC,EAAE,SAAS,GAAG,SAAS,GAAG,IAAI,CAE3D"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAW,SAAS,EAAQ,IAAI,EAAc,MAAM,SAAS,CAAC;AAErF,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAErE;AAED,eAAO,MAAM,QAAQ,EAAE,MAAM,CAAC,IAAI,EAAE,IAAI,CAAkE,CAAC;AAE3G,uFAAuF;AACvF,wBAAgB,OAAO,CAAC,CAAC,EAAE,SAAS,GAAG,IAAI,CAE1C;AAED,iGAAiG;AACjG,wBAAgB,YAAY,CAAC,CAAC,EAAE,SAAS,GAAG,SAAS,GAAG,IAAI,CAE3D"}

package/dist/utils.js

@@ -1,2 +1,2 @@
-import{OrbitConfigError as e}from"./errors.js";import{clamp as t}from"@vielzeug/arsenal/math";var n={bottom:`top`,left:`right`,right:`left`,top:`bottom`};function r(e){return e.split(`-`)[0]}function i(e){return e.split(`-`)[1]??null}function a(e,t){return t?`${e}-${t}`:e}function o({height:e,width:t,x:n,y:r}){return{height:e,width:t,x:n,y:r}}function s(e=0){return typeof e==`number`?{bottom:e,left:e,right:e,top:e}:{bottom:e.bottom??0,left:e.left??0,right:e.right??0,top:e.top??0}}function c(e){return typeof Element<`u`&&e instanceof Element}function l(e){return e.assignedSlot?e.assignedSlot:e.parentElement??(e.getRootNode()instanceof ShadowRoot?e.getRootNode().host:null)}var u=[[`arrow`,`flip`],[`arrow`,`shift`],[`arrow`,`autoPlacement`],[`flip`,`inline`],[`shift`,`inline`],[`autoPlacement`,`inline`],[`size`,`flip`],[`size`,`autoPlacement`]];function d(t){for(let[n,r]of u){let i=t.indexOf(n),a=t.indexOf(r);if(i!==-1&&a!==-1&&i<a)throw new e(`"${n}" must come after "${r}" in the middleware pipeline. Recommended order: inline → offset → flip/autoPlacement → shift → size → arrow.`)}if(t.includes(`flip`)&&t.includes(`autoPlacement`))throw new e(`use either flip() or autoPlacement() in the middleware pipeline, not both.`)}var f=Symbol.for(`@vielzeug/orbit/name`);function p(e,t){return e[f]=t,e}function m(e,t,n,r){return e===`start`?t:e===`end`?t+n-r:t+(n-r)/2}function h(e,t,n){let a=r(e),o=i(e);switch(a){case`bottom`:return{x:m(o,t.x,t.width,n.width),y:t.y+t.height};case`left`:return{x:t.x-n.width,y:m(o,t.y,t.height,n.height)};case`right`:return{x:t.x+t.width,y:m(o,t.y,t.height,n.height)};case`top`:return{x:m(o,t.x,t.width,n.width),y:t.y-n.height}}}export{f as MIDDLEWARE_NAME,u as MIDDLEWARE_ORDER_RULES,n as OPPOSITE,h as baseCoords,t as clamp,l as flatTreeParent,i as getAlignment,r as getSide,c as isElement,p as tagMiddleware,o as toRect,s as toSideObject,d as validateMiddlewareNames,a as withPlacement};
+function e(e,t,n){return Math.min(Math.max(e,t),n)}var t={bottom:`top`,left:`right`,right:`left`,top:`bottom`};function n(e){return e.split(`-`)[0]}function r(e){return e.split(`-`)[1]??null}function i(e,t){return t?`${e}-${t}`:e}function a({height:e,width:t,x:n,y:r}){return{height:e,width:t,x:n,y:r}}function o(e=0){return typeof e==`number`?{bottom:e,left:e,right:e,top:e}:{bottom:e.bottom??0,left:e.left??0,right:e.right??0,top:e.top??0}}function s(e){return typeof Element<`u`&&e instanceof Element}function c(e){return e.assignedSlot?e.assignedSlot:e.parentElement??(e.getRootNode()instanceof ShadowRoot?e.getRootNode().host:null)}function l(e,t,n,r){return e===`start`?t:e===`end`?t+n-r:t+(n-r)/2}function u(e,t,i){let a=n(e),o=r(e);switch(a){case`bottom`:return{x:l(o,t.x,t.width,i.width),y:t.y+t.height};case`left`:return{x:t.x-i.width,y:l(o,t.y,t.height,i.height)};case`right`:return{x:t.x+t.width,y:l(o,t.y,t.height,i.height)};case`top`:return{x:l(o,t.x,t.width,i.width),y:t.y-i.height}}}export{t as OPPOSITE,u as baseCoords,e as clamp,c as flatTreeParent,r as getAlignment,n as getSide,s as isElement,a as toRect,o as toSideObject,i as withPlacement};
 //# sourceMappingURL=utils.js.map

package/dist/utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"utils.js","names":[],"sources":["../src/utils.ts"],"sourcesContent":["import { clamp } from '@vielzeug/arsenal/math';\n\nimport type { Alignment, Middleware, Padding, Placement, Rect, Side, SideObject, TypedMiddleware } from './types';\n\nimport { OrbitConfigError } from './errors';\n\nexport { clamp };\n\nexport const OPPOSITE: Record<Side, Side> = { bottom: 'top', left: 'right', right: 'left', top: 'bottom' };\n\n/** Returns the primary side of a placement (`'top' | 'bottom' | 'left' | 'right'`). */\nexport function getSide(p: Placement): Side {\n  return p.split('-')[0] as Side;\n}\n\n/** Returns the alignment of a placement (`'start' | 'end'`), or `null` for center placements. */\nexport function getAlignment(p: Placement): Alignment | null {\n  return (p.split('-')[1] as Alignment) ?? null;\n}\n\n/** @internal */\nexport function withPlacement(side: Side, align: Alignment | null): Placement {\n  return (align ? `${side}-${align}` : side) as Placement;\n}\n\n/** @internal */\nexport function toRect({ height, width, x, y }: DOMRect | Rect): Rect {\n  return { height, width, x, y };\n}\n\n/** @internal */\nexport function toSideObject(padding: Padding = 0): SideObject {\n  if (typeof padding === 'number') {\n    return { bottom: padding, left: padding, right: padding, top: padding };\n  }\n\n  return {\n    bottom: padding.bottom ?? 0,\n    left: padding.left ?? 0,\n    right: padding.right ?? 0,\n    top: padding.top ?? 0,\n  };\n}\n\n/** @internal */\nexport function isElement(value: unknown): value is Element {\n  return typeof Element !== 'undefined' && value instanceof Element;\n}\n\n/**\n * Returns `node`'s parent in the flat (rendering) tree — the tree CSS layout, paint, and\n * containing-block rules actually walk, which is *not* the same as light-DOM `parentElement`:\n *\n * - If `node` is itself distributed into a `<slot>` (`node.assignedSlot` is set), its rendered\n *   parent is that `<slot>`, which lives inside the shadow tree that projects it — not wherever\n *   `node.parentElement` points in the light DOM. Skipping this check would walk straight past\n *   the shadow host and out into *its* light-DOM ancestors, missing every ancestor between the\n *   `<slot>` and the shadow root (a dialog's `.panel`, say) entirely.\n * - Otherwise, falls back to `parentElement`, or — once that's exhausted at a shadow root\n *   boundary — the shadow root's host, so the walk continues past shadow boundaries instead of\n *   stopping there.\n *\n * `null` once it reaches a true root.\n * @internal\n */\nexport function flatTreeParent(node: Element): Element | null {\n  if (node.assignedSlot) return node.assignedSlot;\n\n  return (\n    node.parentElement ?? (node.getRootNode() instanceof ShadowRoot ? (node.getRootNode() as ShadowRoot).host : null)\n  );\n}\n\n// ── Middleware helpers ────────────────────────────────────────────────────────\n\n/**\n * Ordering rules for dev-mode middleware validation.\n * Each tuple is `[mustFollow, mustPrecede]` — `mustFollow` must appear **after** `mustPrecede`\n * in the pipeline. Validation throws if `mustFollow` is found at a lower index than `mustPrecede`.\n * @internal\n */\nexport const MIDDLEWARE_ORDER_RULES: Array<[mustFollow: string, mustPrecede: string]> = [\n  ['arrow', 'flip'],\n  ['arrow', 'shift'],\n  ['arrow', 'autoPlacement'],\n  ['flip', 'inline'],\n  ['shift', 'inline'],\n  ['autoPlacement', 'inline'],\n  ['size', 'flip'],\n  ['size', 'autoPlacement'],\n];\n\n/**\n * Validates a list of middleware names for known-bad orderings.\n * Throws a descriptive error in dev mode if an invalid ordering is detected.\n * @internal\n */\nexport function validateMiddlewareNames(names: Array<string | null>): void {\n  for (const [mustFollow, mustPrecede] of MIDDLEWARE_ORDER_RULES) {\n    const followIdx = names.indexOf(mustFollow);\n    const precedeIdx = names.indexOf(mustPrecede);\n\n    if (followIdx !== -1 && precedeIdx !== -1 && followIdx < precedeIdx) {\n      throw new OrbitConfigError(\n        `\"${mustFollow}\" must come after \"${mustPrecede}\" in the middleware pipeline. ` +\n          `Recommended order: inline → offset → flip/autoPlacement → shift → size → arrow.`,\n      );\n    }\n  }\n\n  if (names.includes('flip') && names.includes('autoPlacement')) {\n    throw new OrbitConfigError('use either flip() or autoPlacement() in the middleware pipeline, not both.');\n  }\n}\n\n/**\n * Unique symbol used to tag middleware with a name for dev-mode ordering validation.\n * Using a Symbol avoids collisions with any `__name` property set by transpilers or wrappers.\n * @internal\n */\nexport const MIDDLEWARE_NAME = Symbol.for('@vielzeug/orbit/name');\n\n/**\n * Tags a middleware function with a name for dev-mode ordering validation and brands it\n * as a `TypedMiddleware<K, D>` for compile-time `middlewareData` inference.\n * @internal\n */\nexport function tagMiddleware<K extends string, D, F extends Middleware>(fn: F, name: K): F & TypedMiddleware<K, D> {\n  (fn as Record<symbol, unknown>)[MIDDLEWARE_NAME] = name;\n\n  return fn as F & TypedMiddleware<K, D>;\n}\n\n// ── Geometry ──────────────────────────────────────────────────────────────────\n\nfunction alignedOffset(align: Alignment | null, refStart: number, refSize: number, floatSize: number): number {\n  if (align === 'start') return refStart;\n\n  if (align === 'end') return refStart + refSize - floatSize;\n\n  return refStart + (refSize - floatSize) / 2;\n}\n\n/**\n * Computes the base (un-shifted) x/y coordinates for a floating element\n * given the placement and the reference/floating rects.\n * @internal\n */\nexport function baseCoords(placement: Placement, ref: Rect, float: Rect): { x: number; y: number } {\n  const side = getSide(placement);\n  const align = getAlignment(placement);\n\n  switch (side) {\n    case 'bottom':\n      return { x: alignedOffset(align, ref.x, ref.width, float.width), y: ref.y + ref.height };\n    case 'left':\n      return { x: ref.x - float.width, y: alignedOffset(align, ref.y, ref.height, float.height) };\n    case 'right':\n      return { x: ref.x + ref.width, y: alignedOffset(align, ref.y, ref.height, float.height) };\n    case 'top':\n      return { x: alignedOffset(align, ref.x, ref.width, float.width), y: ref.y - float.height };\n  }\n}\n"],"mappings":"8FAQA,IAAa,EAA+B,CAAE,OAAQ,MAAO,KAAM,QAAS,MAAO,OAAQ,IAAK,QAAS,EAGzG,SAAgB,EAAQ,EAAoB,CAC1C,OAAO,EAAE,MAAM,GAAG,CAAC,CAAC,EACtB,CAGA,SAAgB,EAAa,EAAgC,CAC3D,OAAQ,EAAE,MAAM,GAAG,CAAC,CAAC,IAAoB,IAC3C,CAGA,SAAgB,EAAc,EAAY,EAAoC,CAC5E,OAAQ,EAAQ,GAAG,EAAK,GAAG,IAAU,CACvC,CAGA,SAAgB,EAAO,CAAE,SAAQ,QAAO,IAAG,KAA2B,CACpE,MAAO,CAAE,SAAQ,QAAO,IAAG,GAAE,CAC/B,CAGA,SAAgB,EAAa,EAAmB,EAAe,CAK7D,OAJI,OAAO,GAAY,SACd,CAAE,OAAQ,EAAS,KAAM,EAAS,MAAO,EAAS,IAAK,CAAQ,EAGjE,CACL,OAAQ,EAAQ,QAAU,EAC1B,KAAM,EAAQ,MAAQ,EACtB,MAAO,EAAQ,OAAS,EACxB,IAAK,EAAQ,KAAO,CACtB,CACF,CAGA,SAAgB,EAAU,EAAkC,CAC1D,OAAO,OAAO,QAAY,KAAe,aAAiB,OAC5D,CAkBA,SAAgB,EAAe,EAA+B,CAG5D,OAFI,EAAK,aAAqB,EAAK,aAGjC,EAAK,gBAAkB,EAAK,YAAY,YAAa,WAAc,EAAK,YAAY,CAAC,CAAgB,KAAO,KAEhH,CAUA,IAAa,EAA2E,CACtF,CAAC,QAAS,MAAM,EAChB,CAAC,QAAS,OAAO,EACjB,CAAC,QAAS,eAAe,EACzB,CAAC,OAAQ,QAAQ,EACjB,CAAC,QAAS,QAAQ,EAClB,CAAC,gBAAiB,QAAQ,EAC1B,CAAC,OAAQ,MAAM,EACf,CAAC,OAAQ,eAAe,CAC1B,EAOA,SAAgB,EAAwB,EAAmC,CACzE,IAAK,GAAM,CAAC,EAAY,KAAgB,EAAwB,CAC9D,IAAM,EAAY,EAAM,QAAQ,CAAU,EACpC,EAAa,EAAM,QAAQ,CAAW,EAE5C,GAAI,IAAc,IAAM,IAAe,IAAM,EAAY,EACvD,MAAM,IAAI,EACR,IAAI,EAAW,qBAAqB,EAAY,8GAElD,CAEJ,CAEA,GAAI,EAAM,SAAS,MAAM,GAAK,EAAM,SAAS,eAAe,EAC1D,MAAM,IAAI,EAAiB,4EAA4E,CAE3G,CAOA,IAAa,EAAkB,OAAO,IAAI,sBAAsB,EAOhE,SAAgB,EAAyD,EAAO,EAAoC,CAGlH,MAFA,GAAgC,GAAmB,EAE5C,CACT,CAIA,SAAS,EAAc,EAAyB,EAAkB,EAAiB,EAA2B,CAK5G,OAJI,IAAU,QAAgB,EAE1B,IAAU,MAAc,EAAW,EAAU,EAE1C,GAAY,EAAU,GAAa,CAC5C,CAOA,SAAgB,EAAW,EAAsB,EAAW,EAAuC,CACjG,IAAM,EAAO,EAAQ,CAAS,EACxB,EAAQ,EAAa,CAAS,EAEpC,OAAQ,EAAR,CACE,IAAK,SACH,MAAO,CAAE,EAAG,EAAc,EAAO,EAAI,EAAG,EAAI,MAAO,EAAM,KAAK,EAAG,EAAG,EAAI,EAAI,EAAI,MAAO,EACzF,IAAK,OACH,MAAO,CAAE,EAAG,EAAI,EAAI,EAAM,MAAO,EAAG,EAAc,EAAO,EAAI,EAAG,EAAI,OAAQ,EAAM,MAAM,CAAE,EAC5F,IAAK,QACH,MAAO,CAAE,EAAG,EAAI,EAAI,EAAI,MAAO,EAAG,EAAc,EAAO,EAAI,EAAG,EAAI,OAAQ,EAAM,MAAM,CAAE,EAC1F,IAAK,MACH,MAAO,CAAE,EAAG,EAAc,EAAO,EAAI,EAAG,EAAI,MAAO,EAAM,KAAK,EAAG,EAAG,EAAI,EAAI,EAAM,MAAO,CAC7F,CACF"}
+{"version":3,"file":"utils.js","names":[],"sources":["../src/utils.ts"],"sourcesContent":["import type { Alignment, Padding, Placement, Rect, Side, SideObject } from './types';\n\nexport function clamp(value: number, min: number, max: number): number {\n  return Math.min(Math.max(value, min), max);\n}\n\nexport const OPPOSITE: Record<Side, Side> = { bottom: 'top', left: 'right', right: 'left', top: 'bottom' };\n\n/** Returns the primary side of a placement (`'top' | 'bottom' | 'left' | 'right'`). */\nexport function getSide(p: Placement): Side {\n  return p.split('-')[0] as Side;\n}\n\n/** Returns the alignment of a placement (`'start' | 'end'`), or `null` for center placements. */\nexport function getAlignment(p: Placement): Alignment | null {\n  return (p.split('-')[1] as Alignment) ?? null;\n}\n\n/** @internal */\nexport function withPlacement(side: Side, align: Alignment | null): Placement {\n  return (align ? `${side}-${align}` : side) as Placement;\n}\n\n/** @internal */\nexport function toRect({ height, width, x, y }: DOMRect | Rect): Rect {\n  return { height, width, x, y };\n}\n\n/** @internal */\nexport function toSideObject(padding: Padding = 0): SideObject {\n  if (typeof padding === 'number') {\n    return { bottom: padding, left: padding, right: padding, top: padding };\n  }\n\n  return {\n    bottom: padding.bottom ?? 0,\n    left: padding.left ?? 0,\n    right: padding.right ?? 0,\n    top: padding.top ?? 0,\n  };\n}\n\n/** @internal */\nexport function isElement(value: unknown): value is Element {\n  return typeof Element !== 'undefined' && value instanceof Element;\n}\n\n/**\n * Returns `node`'s parent in the flat (rendering) tree — the tree CSS layout, paint, and\n * containing-block rules actually walk, which is *not* the same as light-DOM `parentElement`:\n *\n * - If `node` is itself distributed into a `<slot>` (`node.assignedSlot` is set), its rendered\n *   parent is that `<slot>`, which lives inside the shadow tree that projects it — not wherever\n *   `node.parentElement` points in the light DOM. Skipping this check would walk straight past\n *   the shadow host and out into *its* light-DOM ancestors, missing every ancestor between the\n *   `<slot>` and the shadow root (a dialog's `.panel`, say) entirely.\n * - Otherwise, falls back to `parentElement`, or — once that's exhausted at a shadow root\n *   boundary — the shadow root's host, so the walk continues past shadow boundaries instead of\n *   stopping there.\n *\n * `null` once it reaches a true root.\n * @internal\n */\nexport function flatTreeParent(node: Element): Element | null {\n  if (node.assignedSlot) return node.assignedSlot;\n\n  return (\n    node.parentElement ?? (node.getRootNode() instanceof ShadowRoot ? (node.getRootNode() as ShadowRoot).host : null)\n  );\n}\n\n// ── Geometry ──────────────────────────────────────────────────────────────────\n\nfunction alignedOffset(align: Alignment | null, refStart: number, refSize: number, floatSize: number): number {\n  if (align === 'start') return refStart;\n\n  if (align === 'end') return refStart + refSize - floatSize;\n\n  return refStart + (refSize - floatSize) / 2;\n}\n\n/**\n * Computes the base (un-shifted) x/y coordinates for a floating element\n * given the placement and the reference/floating rects.\n * @internal\n */\nexport function baseCoords(placement: Placement, ref: Rect, float: Rect): { x: number; y: number } {\n  const side = getSide(placement);\n  const align = getAlignment(placement);\n\n  switch (side) {\n    case 'bottom':\n      return { x: alignedOffset(align, ref.x, ref.width, float.width), y: ref.y + ref.height };\n    case 'left':\n      return { x: ref.x - float.width, y: alignedOffset(align, ref.y, ref.height, float.height) };\n    case 'right':\n      return { x: ref.x + ref.width, y: alignedOffset(align, ref.y, ref.height, float.height) };\n    case 'top':\n      return { x: alignedOffset(align, ref.x, ref.width, float.width), y: ref.y - float.height };\n  }\n}\n"],"mappings":"AAEA,SAAgB,EAAM,EAAe,EAAa,EAAqB,CACrE,OAAO,KAAK,IAAI,KAAK,IAAI,EAAO,CAAG,EAAG,CAAG,CAC3C,CAEA,IAAa,EAA+B,CAAE,OAAQ,MAAO,KAAM,QAAS,MAAO,OAAQ,IAAK,QAAS,EAGzG,SAAgB,EAAQ,EAAoB,CAC1C,OAAO,EAAE,MAAM,GAAG,CAAC,CAAC,EACtB,CAGA,SAAgB,EAAa,EAAgC,CAC3D,OAAQ,EAAE,MAAM,GAAG,CAAC,CAAC,IAAoB,IAC3C,CAGA,SAAgB,EAAc,EAAY,EAAoC,CAC5E,OAAQ,EAAQ,GAAG,EAAK,GAAG,IAAU,CACvC,CAGA,SAAgB,EAAO,CAAE,SAAQ,QAAO,IAAG,KAA2B,CACpE,MAAO,CAAE,SAAQ,QAAO,IAAG,GAAE,CAC/B,CAGA,SAAgB,EAAa,EAAmB,EAAe,CAK7D,OAJI,OAAO,GAAY,SACd,CAAE,OAAQ,EAAS,KAAM,EAAS,MAAO,EAAS,IAAK,CAAQ,EAGjE,CACL,OAAQ,EAAQ,QAAU,EAC1B,KAAM,EAAQ,MAAQ,EACtB,MAAO,EAAQ,OAAS,EACxB,IAAK,EAAQ,KAAO,CACtB,CACF,CAGA,SAAgB,EAAU,EAAkC,CAC1D,OAAO,OAAO,QAAY,KAAe,aAAiB,OAC5D,CAkBA,SAAgB,EAAe,EAA+B,CAG5D,OAFI,EAAK,aAAqB,EAAK,aAGjC,EAAK,gBAAkB,EAAK,YAAY,YAAa,WAAc,EAAK,YAAY,CAAC,CAAgB,KAAO,KAEhH,CAIA,SAAS,EAAc,EAAyB,EAAkB,EAAiB,EAA2B,CAK5G,OAJI,IAAU,QAAgB,EAE1B,IAAU,MAAc,EAAW,EAAU,EAE1C,GAAY,EAAU,GAAa,CAC5C,CAOA,SAAgB,EAAW,EAAsB,EAAW,EAAuC,CACjG,IAAM,EAAO,EAAQ,CAAS,EACxB,EAAQ,EAAa,CAAS,EAEpC,OAAQ,EAAR,CACE,IAAK,SACH,MAAO,CAAE,EAAG,EAAc,EAAO,EAAI,EAAG,EAAI,MAAO,EAAM,KAAK,EAAG,EAAG,EAAI,EAAI,EAAI,MAAO,EACzF,IAAK,OACH,MAAO,CAAE,EAAG,EAAI,EAAI,EAAM,MAAO,EAAG,EAAc,EAAO,EAAI,EAAG,EAAI,OAAQ,EAAM,MAAM,CAAE,EAC5F,IAAK,QACH,MAAO,CAAE,EAAG,EAAI,EAAI,EAAI,MAAO,EAAG,EAAc,EAAO,EAAI,EAAG,EAAI,OAAQ,EAAM,MAAM,CAAE,EAC1F,IAAK,MACH,MAAO,CAAE,EAAG,EAAc,EAAO,EAAI,EAAG,EAAI,MAAO,EAAM,KAAK,EAAG,EAAG,EAAI,EAAI,EAAM,MAAO,CAC7F,CACF"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vielzeug/orbit",
-  "version": "1.1.4",
-  "description": "Floating element positioning — tooltip, dropdown, popover, and menu placement with middleware",
+  "version": "2.0.0",
+  "description": "Dependency-free floating UI positioning with lifecycle-owned geometry and middleware",
   "type": "module",
   "files": [
     "dist"
@@ -11,34 +11,24 @@
   "types": "dist/index.d.ts",
   "exports": {
     ".": {
-      "source": "./src/index.ts",
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "require": "./dist/index.cjs"
     },
     "./devtools": {
-      "source": "./src/devtools.ts",
       "types": "./dist/devtools.d.ts",
       "import": "./dist/devtools.js",
       "require": "./dist/devtools.cjs"
     },
     "./presets": {
-      "source": "./src/presets.ts",
       "types": "./dist/presets.d.ts",
       "import": "./dist/presets.js",
       "require": "./dist/presets.cjs"
     },
     "./reactive": {
-      "source": "./src/reactive.ts",
       "types": "./dist/reactive.d.ts",
       "import": "./dist/reactive.js",
       "require": "./dist/reactive.cjs"
-    },
-    "./ssr": {
-      "source": "./src/ssr.ts",
-      "types": "./dist/ssr.d.ts",
-      "import": "./dist/ssr.js",
-      "require": "./dist/ssr.cjs"
     }
   },
   "scripts": {
@@ -57,14 +47,32 @@
   "engines": {
     "node": ">=22"
   },
-  "dependencies": {
-    "@vielzeug/arsenal": "2.0.0",
-    "@vielzeug/ripple": "2.0.0"
+  "peerDependencies": {
+    "@vielzeug/ripple": "^2.0.1"
+  },
+  "peerDependenciesMeta": {
+    "@vielzeug/ripple": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@types/node": "^26.1.2",
+    "@vielzeug/ripple": "2.0.1",
     "typescript": "^6.0.3",
     "vite": "^8.2.0",
     "vitest": "^4.1.10"
+  },
+  "typesVersions": {
+    "*": {
+      "devtools": [
+        "dist/devtools.d.ts"
+      ],
+      "presets": [
+        "dist/presets.d.ts"
+      ],
+      "reactive": [
+        "dist/reactive.d.ts"
+      ]
+    }
   }
 }

package/dist/compose.cjs

@@ -1,2 +0,0 @@
-function e(...e){return e.filter(Boolean)}exports.compose=e;
-//# sourceMappingURL=compose.cjs.map

package/dist/compose.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"compose.cjs","names":[],"sources":["../src/compose.ts"],"sourcesContent":["import type { Middleware } from './types';\n\ntype Falsy = false | null | undefined;\n\n/**\n * Filters out falsy middleware entries (`null`, `undefined`, `false`) and returns a clean array.\n *\n * Middleware ordering validation runs automatically inside `computePosition()` in development —\n * you do not need `compose()` to get ordering warnings. Use it purely for its falsy-filter\n * ergonomics when conditionally including middleware.\n *\n * @example\n * ```ts\n * import { compose, offset, flip, shift, arrow } from '@vielzeug/orbit';\n *\n * const middleware = compose(\n *   offset(8),\n *   flip(),\n *   shift({ padding: 6 }),\n *   hasArrow && arrow({ element: arrowEl }),\n * );\n * float(trigger, tooltip, { middleware });\n * ```\n */\nexport function compose(...middleware: Array<Middleware | Falsy>): Middleware[] {\n  return middleware.filter(Boolean) as Middleware[];\n}\n"],"mappings":"AAwBA,SAAgB,EAAQ,GAAG,EAAqD,CAC9E,OAAO,EAAW,OAAO,OAAO,CAClC"}

package/dist/compose.d.ts

@@ -1,25 +0,0 @@
-import type { Middleware } from './types';
-type Falsy = false | null | undefined;
-/**
- * Filters out falsy middleware entries (`null`, `undefined`, `false`) and returns a clean array.
- *
- * Middleware ordering validation runs automatically inside `computePosition()` in development —
- * you do not need `compose()` to get ordering warnings. Use it purely for its falsy-filter
- * ergonomics when conditionally including middleware.
- *
- * @example
- * ```ts
- * import { compose, offset, flip, shift, arrow } from '@vielzeug/orbit';
- *
- * const middleware = compose(
- *   offset(8),
- *   flip(),
- *   shift({ padding: 6 }),
- *   hasArrow && arrow({ element: arrowEl }),
- * );
- * float(trigger, tooltip, { middleware });
- * ```
- */
-export declare function compose(...middleware: Array<Middleware | Falsy>): Middleware[];
-export {};
-//# sourceMappingURL=compose.d.ts.map

package/dist/compose.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"compose.d.ts","sourceRoot":"","sources":["../src/compose.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAE1C,KAAK,KAAK,GAAG,KAAK,GAAG,IAAI,GAAG,SAAS,CAAC;AAEtC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,OAAO,CAAC,GAAG,UAAU,EAAE,KAAK,CAAC,UAAU,GAAG,KAAK,CAAC,GAAG,UAAU,EAAE,CAE9E"}

package/dist/compose.js

@@ -1,2 +0,0 @@
-function e(...e){return e.filter(Boolean)}export{e as compose};
-//# sourceMappingURL=compose.js.map

package/dist/compose.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"compose.js","names":[],"sources":["../src/compose.ts"],"sourcesContent":["import type { Middleware } from './types';\n\ntype Falsy = false | null | undefined;\n\n/**\n * Filters out falsy middleware entries (`null`, `undefined`, `false`) and returns a clean array.\n *\n * Middleware ordering validation runs automatically inside `computePosition()` in development —\n * you do not need `compose()` to get ordering warnings. Use it purely for its falsy-filter\n * ergonomics when conditionally including middleware.\n *\n * @example\n * ```ts\n * import { compose, offset, flip, shift, arrow } from '@vielzeug/orbit';\n *\n * const middleware = compose(\n *   offset(8),\n *   flip(),\n *   shift({ padding: 6 }),\n *   hasArrow && arrow({ element: arrowEl }),\n * );\n * float(trigger, tooltip, { middleware });\n * ```\n */\nexport function compose(...middleware: Array<Middleware | Falsy>): Middleware[] {\n  return middleware.filter(Boolean) as Middleware[];\n}\n"],"mappings":"AAwBA,SAAgB,EAAQ,GAAG,EAAqD,CAC9E,OAAO,EAAW,OAAO,OAAO,CAClC"}

package/dist/ssr.cjs

@@ -1,2 +0,0 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./float.cjs");var t=()=>{},n=(e=`bottom`)=>({middlewareData:{},placement:e,x:0,y:0});function r(e,t,r={}){return Promise.resolve(n(r.placement))}function i(e,t,r={}){return Promise.resolve(n(r.placement))}function a(e,t,r={}){return n(r.placement)}function o(e,n,r,i){return t}function s(n,r,i){return e.makeHandle(t,()=>null,t)}exports.autoUpdate=o,exports.computePosition=a,exports.computePositionAsync=i,exports.computePositionRaf=r,exports.float=s;
-//# sourceMappingURL=ssr.cjs.map

package/dist/ssr.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"ssr.cjs","names":[],"sources":["../src/ssr.ts"],"sourcesContent":["/**\n * @vielzeug/orbit/ssr — no-op stubs for server-side rendering.\n *\n * Import this sub-path in SSR environments (Node.js, Deno, Bun) instead of the\n * main entry to avoid `getBoundingClientRect`, `window`, and `document` references\n * that are unavailable server-side.\n *\n * ```ts\n * // vite.config.ts (or equivalent)\n * resolve: {\n *   alias: {\n *     '@vielzeug/orbit': process.env.SSR ? '@vielzeug/orbit/ssr' : '@vielzeug/orbit',\n *   },\n * }\n * ```\n */\n\nimport type { AutoUpdateOptions } from './auto-update';\nimport type { FloatOptions } from './float';\nimport type { ComputePositionOptions, ComputePositionResult, FloatHandle, ReferenceElement } from './types';\n\nimport { makeHandle } from './float';\n\nconst NOOP: () => void = () => {};\n\nconst NULL_RESULT = (placement: ComputePositionOptions['placement'] = 'bottom'): ComputePositionResult => ({\n  middlewareData: {},\n  placement,\n  x: 0,\n  y: 0,\n});\n\n/**\n * No-op stub. Resolves immediately with zero-coordinate result.\n */\nexport function computePositionRaf(\n  _reference: ReferenceElement,\n  _floating: HTMLElement,\n  options: ComputePositionOptions = {},\n): Promise<ComputePositionResult> {\n  return Promise.resolve(NULL_RESULT(options.placement));\n}\n\n/**\n * No-op stub. Resolves immediately with zero-coordinate result.\n */\nexport function computePositionAsync(\n  _reference: ReferenceElement,\n  _floating: HTMLElement,\n  options: ComputePositionOptions = {},\n): Promise<ComputePositionResult> {\n  return Promise.resolve(NULL_RESULT(options.placement));\n}\n\n/**\n * No-op stub. Returns zero-coordinate result with the requested placement.\n */\nexport function computePosition(\n  _reference: ReferenceElement,\n  _floating: HTMLElement,\n  options: ComputePositionOptions = {},\n): ComputePositionResult {\n  return NULL_RESULT(options.placement);\n}\n\n/**\n * No-op stub. Returns a no-op cleanup function.\n */\nexport function autoUpdate(\n  _reference: ReferenceElement,\n  _floating: HTMLElement,\n  _update: () => void,\n  _options?: AutoUpdateOptions,\n): () => void {\n  return NOOP;\n}\n\n/**\n * No-op stub. Returns a FloatHandle with no-op methods. `getPosition()` always returns `null`\n * (position is never computed in an SSR environment).\n */\nexport function float(_reference: ReferenceElement, _floating: HTMLElement, _options?: FloatOptions): FloatHandle {\n  return makeHandle(NOOP, () => null, NOOP);\n}\n"],"mappings":"kGAuBA,IAAM,MAAyB,CAAC,EAE1B,GAAe,EAAiD,YAAqC,CACzG,eAAgB,CAAC,EACjB,YACA,EAAG,EACH,EAAG,CACL,GAKA,SAAgB,EACd,EACA,EACA,EAAkC,CAAC,EACH,CAChC,OAAO,QAAQ,QAAQ,EAAY,EAAQ,SAAS,CAAC,CACvD,CAKA,SAAgB,EACd,EACA,EACA,EAAkC,CAAC,EACH,CAChC,OAAO,QAAQ,QAAQ,EAAY,EAAQ,SAAS,CAAC,CACvD,CAKA,SAAgB,EACd,EACA,EACA,EAAkC,CAAC,EACZ,CACvB,OAAO,EAAY,EAAQ,SAAS,CACtC,CAKA,SAAgB,EACd,EACA,EACA,EACA,EACY,CACZ,OAAO,CACT,CAMA,SAAgB,EAAM,EAA8B,EAAwB,EAAsC,CAChH,OAAO,EAAA,WAAW,MAAY,KAAM,CAAI,CAC1C"}

package/dist/ssr.d.ts

@@ -1,41 +0,0 @@
-/**
- * @vielzeug/orbit/ssr — no-op stubs for server-side rendering.
- *
- * Import this sub-path in SSR environments (Node.js, Deno, Bun) instead of the
- * main entry to avoid `getBoundingClientRect`, `window`, and `document` references
- * that are unavailable server-side.
- *
- * ```ts
- * // vite.config.ts (or equivalent)
- * resolve: {
- *   alias: {
- *     '@vielzeug/orbit': process.env.SSR ? '@vielzeug/orbit/ssr' : '@vielzeug/orbit',
- *   },
- * }
- * ```
- */
-import type { AutoUpdateOptions } from './auto-update';
-import type { FloatOptions } from './float';
-import type { ComputePositionOptions, ComputePositionResult, FloatHandle, ReferenceElement } from './types';
-/**
- * No-op stub. Resolves immediately with zero-coordinate result.
- */
-export declare function computePositionRaf(_reference: ReferenceElement, _floating: HTMLElement, options?: ComputePositionOptions): Promise<ComputePositionResult>;
-/**
- * No-op stub. Resolves immediately with zero-coordinate result.
- */
-export declare function computePositionAsync(_reference: ReferenceElement, _floating: HTMLElement, options?: ComputePositionOptions): Promise<ComputePositionResult>;
-/**
- * No-op stub. Returns zero-coordinate result with the requested placement.
- */
-export declare function computePosition(_reference: ReferenceElement, _floating: HTMLElement, options?: ComputePositionOptions): ComputePositionResult;
-/**
- * No-op stub. Returns a no-op cleanup function.
- */
-export declare function autoUpdate(_reference: ReferenceElement, _floating: HTMLElement, _update: () => void, _options?: AutoUpdateOptions): () => void;
-/**
- * No-op stub. Returns a FloatHandle with no-op methods. `getPosition()` always returns `null`
- * (position is never computed in an SSR environment).
- */
-export declare function float(_reference: ReferenceElement, _floating: HTMLElement, _options?: FloatOptions): FloatHandle;
-//# sourceMappingURL=ssr.d.ts.map

package/dist/ssr.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ssr.d.ts","sourceRoot":"","sources":["../src/ssr.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AACvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAC5C,OAAO,KAAK,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAa5G;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,gBAAgB,EAC5B,SAAS,EAAE,WAAW,EACtB,OAAO,GAAE,sBAA2B,GACnC,OAAO,CAAC,qBAAqB,CAAC,CAEhC;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,gBAAgB,EAC5B,SAAS,EAAE,WAAW,EACtB,OAAO,GAAE,sBAA2B,GACnC,OAAO,CAAC,qBAAqB,CAAC,CAEhC;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC7B,UAAU,EAAE,gBAAgB,EAC5B,SAAS,EAAE,WAAW,EACtB,OAAO,GAAE,sBAA2B,GACnC,qBAAqB,CAEvB;AAED;;GAEG;AACH,wBAAgB,UAAU,CACxB,UAAU,EAAE,gBAAgB,EAC5B,SAAS,EAAE,WAAW,EACtB,OAAO,EAAE,MAAM,IAAI,EACnB,QAAQ,CAAC,EAAE,iBAAiB,GAC3B,MAAM,IAAI,CAEZ;AAED;;;GAGG;AACH,wBAAgB,KAAK,CAAC,UAAU,EAAE,gBAAgB,EAAE,SAAS,EAAE,WAAW,EAAE,QAAQ,CAAC,EAAE,YAAY,GAAG,WAAW,CAEhH"}

package/dist/ssr.js

@@ -1,2 +0,0 @@
-import{makeHandle as e}from"./float.js";var t=()=>{},n=(e=`bottom`)=>({middlewareData:{},placement:e,x:0,y:0});function r(e,t,r={}){return Promise.resolve(n(r.placement))}function i(e,t,r={}){return Promise.resolve(n(r.placement))}function a(e,t,r={}){return n(r.placement)}function o(e,n,r,i){return t}function s(n,r,i){return e(t,()=>null,t)}export{o as autoUpdate,a as computePosition,i as computePositionAsync,r as computePositionRaf,s as float};
-//# sourceMappingURL=ssr.js.map

package/dist/ssr.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ssr.js","names":[],"sources":["../src/ssr.ts"],"sourcesContent":["/**\n * @vielzeug/orbit/ssr — no-op stubs for server-side rendering.\n *\n * Import this sub-path in SSR environments (Node.js, Deno, Bun) instead of the\n * main entry to avoid `getBoundingClientRect`, `window`, and `document` references\n * that are unavailable server-side.\n *\n * ```ts\n * // vite.config.ts (or equivalent)\n * resolve: {\n *   alias: {\n *     '@vielzeug/orbit': process.env.SSR ? '@vielzeug/orbit/ssr' : '@vielzeug/orbit',\n *   },\n * }\n * ```\n */\n\nimport type { AutoUpdateOptions } from './auto-update';\nimport type { FloatOptions } from './float';\nimport type { ComputePositionOptions, ComputePositionResult, FloatHandle, ReferenceElement } from './types';\n\nimport { makeHandle } from './float';\n\nconst NOOP: () => void = () => {};\n\nconst NULL_RESULT = (placement: ComputePositionOptions['placement'] = 'bottom'): ComputePositionResult => ({\n  middlewareData: {},\n  placement,\n  x: 0,\n  y: 0,\n});\n\n/**\n * No-op stub. Resolves immediately with zero-coordinate result.\n */\nexport function computePositionRaf(\n  _reference: ReferenceElement,\n  _floating: HTMLElement,\n  options: ComputePositionOptions = {},\n): Promise<ComputePositionResult> {\n  return Promise.resolve(NULL_RESULT(options.placement));\n}\n\n/**\n * No-op stub. Resolves immediately with zero-coordinate result.\n */\nexport function computePositionAsync(\n  _reference: ReferenceElement,\n  _floating: HTMLElement,\n  options: ComputePositionOptions = {},\n): Promise<ComputePositionResult> {\n  return Promise.resolve(NULL_RESULT(options.placement));\n}\n\n/**\n * No-op stub. Returns zero-coordinate result with the requested placement.\n */\nexport function computePosition(\n  _reference: ReferenceElement,\n  _floating: HTMLElement,\n  options: ComputePositionOptions = {},\n): ComputePositionResult {\n  return NULL_RESULT(options.placement);\n}\n\n/**\n * No-op stub. Returns a no-op cleanup function.\n */\nexport function autoUpdate(\n  _reference: ReferenceElement,\n  _floating: HTMLElement,\n  _update: () => void,\n  _options?: AutoUpdateOptions,\n): () => void {\n  return NOOP;\n}\n\n/**\n * No-op stub. Returns a FloatHandle with no-op methods. `getPosition()` always returns `null`\n * (position is never computed in an SSR environment).\n */\nexport function float(_reference: ReferenceElement, _floating: HTMLElement, _options?: FloatOptions): FloatHandle {\n  return makeHandle(NOOP, () => null, NOOP);\n}\n"],"mappings":"wCAuBA,IAAM,MAAyB,CAAC,EAE1B,GAAe,EAAiD,YAAqC,CACzG,eAAgB,CAAC,EACjB,YACA,EAAG,EACH,EAAG,CACL,GAKA,SAAgB,EACd,EACA,EACA,EAAkC,CAAC,EACH,CAChC,OAAO,QAAQ,QAAQ,EAAY,EAAQ,SAAS,CAAC,CACvD,CAKA,SAAgB,EACd,EACA,EACA,EAAkC,CAAC,EACH,CAChC,OAAO,QAAQ,QAAQ,EAAY,EAAQ,SAAS,CAAC,CACvD,CAKA,SAAgB,EACd,EACA,EACA,EAAkC,CAAC,EACZ,CACvB,OAAO,EAAY,EAAQ,SAAS,CACtC,CAKA,SAAgB,EACd,EACA,EACA,EACA,EACY,CACZ,OAAO,CACT,CAMA,SAAgB,EAAM,EAA8B,EAAwB,EAAsC,CAChH,OAAO,EAAW,MAAY,KAAM,CAAI,CAC1C"}