@jgengine/core 0.10.0 → 0.11.0

package/dist/ui/selectionModel.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Headless view model for a multi-entity selection — the data layer behind an RTS selection panel, a
+ * party frame, or a squad summary. It turns a caller-owned list of selected entity summaries into a
+ * primary detail focus, an ordered member strip, and same-kind buckets for large selections, with
+ * focus/hover and virtualization helpers. No rendering opinion: the React renderers in
+ * `@jgengine/react/selectionHud` consume this and a game supplies the entity data from wherever it
+ * lives (a `createSelectionSet`, a roster, a marquee query).
+ */
+/** One vital bar on an entity summary (health/shield/energy): current/max plus optional label and tone. */
+export interface EntityVital {
+    id: string;
+    label?: string;
+    current: number;
+    max: number;
+    /** Colour-ramp hint the renderer maps to a palette (e.g. `"health" | "shield"`); caller-owned. */
+    tone?: string;
+}
+/**
+ * A caller-provided summary of one selectable entity — the DATA input. `kind` is the grouping key
+ * used to bucket a large selection (unit type, catalog id); `icon` is a portrait id the renderer
+ * resolves. Only `id` is required.
+ */
+export interface EntitySummaryDef {
+    id: string;
+    name?: string;
+    /** Type/catalog id a large selection is bucketed by; falls back to `"unit"` when omitted. */
+    kind?: string;
+    /** Portrait id / glyph the caller maps to art. */
+    icon?: string;
+    vitals?: readonly EntityVital[];
+    tags?: readonly string[];
+    /** Ownership / faction tint id, caller-owned. */
+    owner?: string;
+}
+/** A bucket of same-`kind` entities in a large selection — the RTS "12 Marines" control chip. */
+export interface SelectionGroup {
+    kind: string;
+    label: string;
+    icon?: string;
+    count: number;
+    ids: readonly string[];
+}
+/**
+ * A resolved multi-selection view model. `primary` is the focused entity's full detail; `members` is
+ * the stable-order strip; `groups` buckets members by kind (count-desc, then label) for the
+ * portrait-overflow case; `grouped` is the hint that the selection is large enough to prefer groups
+ * over per-member portraits.
+ */
+export interface SelectionView {
+    count: number;
+    primary: EntitySummaryDef | null;
+    members: readonly EntitySummaryDef[];
+    groups: readonly SelectionGroup[];
+    focusIndex: number;
+    grouped: boolean;
+}
+/** Options for {@link summarizeSelection}. */
+export interface SummarizeSelectionOptions {
+    /** Id of the entity to treat as primary/focused. Wins over `focusIndex`; ignored when not present. */
+    primaryId?: string;
+    /** Index of the primary/focused member when `primaryId` is absent (default 0). */
+    focusIndex?: number;
+    /** Member count above which `grouped` flips true (default 12). */
+    groupThreshold?: number;
+    /** Map a `kind` to a display label for its group (default: the kind itself). */
+    labelOf?: (kind: string) => string;
+}
+/**
+ * Summarize a selected-entity list into a {@link SelectionView}: resolve the primary focus, keep the
+ * ordered members, and bucket them by `kind`. Pure and stable — deterministic group ordering and a
+ * clamped focus index, so it is safe to call every render and to assert on in a test.
+ */
+export declare function summarizeSelection(members: readonly EntitySummaryDef[], options?: SummarizeSelectionOptions): SelectionView;
+/** A 1-D focus move within the selection member strip. */
+export type SelectionFocusDirection = "next" | "prev" | "first" | "last";
+/**
+ * Pure next-focus math for the selection strip: step the focus index by one member (wrapping), or
+ * jump to an end. `-1` (no focus) steps to the first/last member. Returns `-1` for an empty selection.
+ */
+export declare function moveSelectionFocus(count: number, current: number, dir: SelectionFocusDirection): number;
+/** A contiguous slice of members for virtualizing a large selection strip. */
+export interface SelectionWindow {
+    start: number;
+    end: number;
+    items: readonly EntitySummaryDef[];
+}
+/**
+ * Compute a virtualization window over a large selection: a `size`-length slice starting near
+ * `scroll`, clamped so the window never runs past the end. Render only `items`, offsetting by
+ * `start * itemSize`, to keep a thousand-unit selection from mounting a thousand portraits.
+ */
+export declare function selectionWindow(members: readonly EntitySummaryDef[], scroll: number, size: number): SelectionWindow;

package/dist/ui/selectionModel.js

@@ -0,0 +1,88 @@
+/**
+ * Headless view model for a multi-entity selection — the data layer behind an RTS selection panel, a
+ * party frame, or a squad summary. It turns a caller-owned list of selected entity summaries into a
+ * primary detail focus, an ordered member strip, and same-kind buckets for large selections, with
+ * focus/hover and virtualization helpers. No rendering opinion: the React renderers in
+ * `@jgengine/react/selectionHud` consume this and a game supplies the entity data from wherever it
+ * lives (a `createSelectionSet`, a roster, a marquee query).
+ */
+/**
+ * Summarize a selected-entity list into a {@link SelectionView}: resolve the primary focus, keep the
+ * ordered members, and bucket them by `kind`. Pure and stable — deterministic group ordering and a
+ * clamped focus index, so it is safe to call every render and to assert on in a test.
+ */
+export function summarizeSelection(members, options) {
+    const count = members.length;
+    const threshold = options?.groupThreshold ?? 12;
+    const labelOf = options?.labelOf ?? ((kind) => kind);
+    let focusIndex = -1;
+    if (options?.primaryId !== undefined) {
+        focusIndex = members.findIndex((m) => m.id === options.primaryId);
+    }
+    if (focusIndex < 0)
+        focusIndex = options?.focusIndex ?? 0;
+    focusIndex = count === 0 ? -1 : Math.max(0, Math.min(count - 1, focusIndex));
+    const primary = focusIndex < 0 ? null : (members[focusIndex] ?? null);
+    return {
+        count,
+        primary,
+        members,
+        groups: groupSelection(members, labelOf),
+        focusIndex,
+        grouped: count > threshold,
+    };
+}
+/** @internal Bucket members by `kind` into count-desc, label-asc ordered {@link SelectionGroup}s. */
+function groupSelection(members, labelOf) {
+    const order = [];
+    const byKind = new Map();
+    for (const member of members) {
+        const kind = member.kind ?? "unit";
+        let bucket = byKind.get(kind);
+        if (bucket === undefined) {
+            bucket = { icon: member.icon, ids: [] };
+            byKind.set(kind, bucket);
+            order.push(kind);
+        }
+        bucket.ids.push(member.id);
+    }
+    const groups = order.map((kind) => {
+        const bucket = byKind.get(kind);
+        const group = { kind, label: labelOf(kind), count: bucket.ids.length, ids: bucket.ids };
+        if (bucket.icon !== undefined)
+            group.icon = bucket.icon;
+        return group;
+    });
+    groups.sort((a, b) => (b.count - a.count) || a.label.localeCompare(b.label));
+    return groups;
+}
+/**
+ * Pure next-focus math for the selection strip: step the focus index by one member (wrapping), or
+ * jump to an end. `-1` (no focus) steps to the first/last member. Returns `-1` for an empty selection.
+ */
+export function moveSelectionFocus(count, current, dir) {
+    if (count <= 0)
+        return -1;
+    if (dir === "first")
+        return 0;
+    if (dir === "last")
+        return count - 1;
+    if (current < 0)
+        return dir === "prev" ? count - 1 : 0;
+    if (dir === "next")
+        return (current + 1) % count;
+    return (current - 1 + count) % count;
+}
+/**
+ * Compute a virtualization window over a large selection: a `size`-length slice starting near
+ * `scroll`, clamped so the window never runs past the end. Render only `items`, offsetting by
+ * `start * itemSize`, to keep a thousand-unit selection from mounting a thousand portraits.
+ */
+export function selectionWindow(members, scroll, size) {
+    const count = members.length;
+    const windowSize = Math.max(1, Math.floor(size));
+    const maxStart = Math.max(0, count - windowSize);
+    const start = Math.max(0, Math.min(maxStart, Math.floor(scroll)));
+    const end = Math.min(count, start + windowSize);
+    return { start, end, items: members.slice(start, end) };
+}

package/dist/ui/tooltipModel.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Headless model for HUD tooltips and popovers — the shared description seam games have been
+ * hand-rolling with a bare DOM `title=` attribute. {@link actionTooltip} turns a
+ * {@link ResolvedAction} into structured {@link TooltipContent} (title, cost, cooldown, blocking
+ * notes), and {@link placePopover} is the pure, SSR-safe positioning math the React tooltip uses to
+ * flip and clamp against the viewport. Both are rendering-agnostic.
+ */
+import type { ActionCooldown, ActionCost, ResolvedAction } from "./actionModel.js";
+/** Structured tooltip content — a renderer lays these fields out; the model owns what is shown. */
+export interface TooltipContent {
+    title: string;
+    subtitle?: string;
+    body?: string;
+    /** Hotkey label to echo (e.g. `"Q"`). */
+    hotkey?: string;
+    costs?: readonly ActionCost[];
+    cooldown?: ActionCooldown | null;
+    /** Blocking reasons rendered as a warning footer (why the action is unavailable). */
+    notes?: readonly string[];
+}
+/**
+ * Build {@link TooltipContent} from a {@link ResolvedAction}: title from the label, the group as a
+ * subtitle, the description as the body, and the blocking reasons as warning notes. The single place
+ * an action's tooltip copy is assembled, so every renderer shows the same thing.
+ */
+export declare function actionTooltip(action: ResolvedAction): TooltipContent;
+/** Which side of its anchor a popover opens toward. */
+export type PopoverSide = "top" | "bottom" | "left" | "right";
+/** A positioned rectangle (viewport/anchor space, top-left origin, pixels). */
+export interface UiRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** A width/height pair (pixels). */
+export interface UiSize {
+    width: number;
+    height: number;
+}
+/** The resolved popover position — the side it actually opened on and its clamped top-left. */
+export interface PopoverPlacement {
+    side: PopoverSide;
+    left: number;
+    top: number;
+}
+/** Options for {@link placePopover}. */
+export interface PopoverOptions {
+    /** Side to try first (default `"top"`). Flips to the opposite when it would overflow. */
+    preferred?: PopoverSide;
+    /** Gap between the anchor and the popover, in pixels (default 8). */
+    gap?: number;
+    /** Minimum inset from the viewport edges, in pixels (default 8). */
+    margin?: number;
+}
+/**
+ * Position a popover/tooltip of `content` size against its `anchor` rectangle inside `viewport`:
+ * open on the `preferred` side, flip to the opposite when that side lacks room and the opposite has
+ * more, then clamp the top-left so the box stays fully on screen (respecting `margin`). Pure and
+ * deterministic — no DOM reads — so it is SSR-safe and unit-testable, and the React tooltip is a thin
+ * shell over it.
+ */
+export declare function placePopover(anchor: UiRect, content: UiSize, viewport: UiSize, options?: PopoverOptions): PopoverPlacement;

package/dist/ui/tooltipModel.js

@@ -0,0 +1,82 @@
+/**
+ * Headless model for HUD tooltips and popovers — the shared description seam games have been
+ * hand-rolling with a bare DOM `title=` attribute. {@link actionTooltip} turns a
+ * {@link ResolvedAction} into structured {@link TooltipContent} (title, cost, cooldown, blocking
+ * notes), and {@link placePopover} is the pure, SSR-safe positioning math the React tooltip uses to
+ * flip and clamp against the viewport. Both are rendering-agnostic.
+ */
+/**
+ * Build {@link TooltipContent} from a {@link ResolvedAction}: title from the label, the group as a
+ * subtitle, the description as the body, and the blocking reasons as warning notes. The single place
+ * an action's tooltip copy is assembled, so every renderer shows the same thing.
+ */
+export function actionTooltip(action) {
+    const content = { title: action.label };
+    if (action.group !== undefined)
+        content.subtitle = action.group;
+    if (action.description !== undefined)
+        content.body = action.description;
+    if (action.hotkey !== undefined)
+        content.hotkey = action.hotkey;
+    if (action.costs.length > 0)
+        content.costs = action.costs;
+    if (action.cooldown !== null && !action.cooldown.ready)
+        content.cooldown = action.cooldown;
+    if (action.reasons.length > 0)
+        content.notes = action.reasons.map((reason) => reason.message);
+    return content;
+}
+const OPPOSITE = {
+    top: "bottom",
+    bottom: "top",
+    left: "right",
+    right: "left",
+};
+const clamp = (value, min, max) => Math.max(min, Math.min(max, max < min ? min : value));
+/** @internal Room in pixels between the anchor and the viewport edge on a given side. */
+function roomOn(side, anchor, viewport) {
+    if (side === "top")
+        return anchor.y;
+    if (side === "bottom")
+        return viewport.height - (anchor.y + anchor.height);
+    if (side === "left")
+        return anchor.x;
+    return viewport.width - (anchor.x + anchor.width);
+}
+/** @internal The top-left of `content` placed on `side` of `anchor`, before viewport clamping. */
+function topLeftFor(side, anchor, content, gap) {
+    if (side === "top") {
+        return { left: anchor.x + anchor.width / 2 - content.width / 2, top: anchor.y - gap - content.height };
+    }
+    if (side === "bottom") {
+        return { left: anchor.x + anchor.width / 2 - content.width / 2, top: anchor.y + anchor.height + gap };
+    }
+    if (side === "left") {
+        return { left: anchor.x - gap - content.width, top: anchor.y + anchor.height / 2 - content.height / 2 };
+    }
+    return { left: anchor.x + anchor.width + gap, top: anchor.y + anchor.height / 2 - content.height / 2 };
+}
+/**
+ * Position a popover/tooltip of `content` size against its `anchor` rectangle inside `viewport`:
+ * open on the `preferred` side, flip to the opposite when that side lacks room and the opposite has
+ * more, then clamp the top-left so the box stays fully on screen (respecting `margin`). Pure and
+ * deterministic — no DOM reads — so it is SSR-safe and unit-testable, and the React tooltip is a thin
+ * shell over it.
+ */
+export function placePopover(anchor, content, viewport, options) {
+    const gap = options?.gap ?? 8;
+    const margin = options?.margin ?? 8;
+    const preferred = options?.preferred ?? "top";
+    const needed = preferred === "top" || preferred === "bottom" ? content.height : content.width;
+    let side = preferred;
+    const opposite = OPPOSITE[preferred];
+    if (roomOn(preferred, anchor, viewport) < needed + gap && roomOn(opposite, anchor, viewport) > roomOn(preferred, anchor, viewport)) {
+        side = opposite;
+    }
+    const { left, top } = topLeftFor(side, anchor, content, gap);
+    return {
+        side,
+        left: clamp(left, margin, viewport.width - content.width - margin),
+        top: clamp(top, margin, viewport.height - content.height - margin),
+    };
+}

package/dist/ui.d.ts

@@ -0,0 +1,15 @@
+export { formatDistance } from "./format/distance.js";
+export { formatDelta, formatDuration, formatOrdinal } from "./format/duration.js";
+export { formatSpeed } from "./format/speed.js";
+export { resolveGameLook, type LookPreset } from "./render/lookPreset.js";
+export { STUDIO_STAGE_POST, type GradeConfig, type PostProcessingConfig, type ToneMappingMode, } from "./render/postProcessing.js";
+export { BUILT_IN_SETTING_CATEGORIES, DEFAULT_GRAPHICS_QUALITY, DEFAULT_GRAPHICS_SHADOWS, DEFAULT_MASTER_VOLUME, DEFAULT_UI_SCALE, GRAPHICS_QUALITY_DPR, GRAPHICS_QUALITY_OPTIONS, SETTING_IDS, UI_SCALE_MAX, UI_SCALE_MIN, busVolumeSettingId, createSettingsStore, type GameSettingDef, type GameSettingsConfig, type GraphicsQuality, type SettingCategory, type SettingCategoryDef, type SettingKind, type SettingOption, type SettingValue, type SettingsActionDef, type SettingsStore, type SettingsSurface, type SettingsVariant, } from "./settings/settingsModel.js";
+export { actionByHotkey, actionCooldown, actionCooldownFromFraction, actionCost, moveGridFocus, resolveAction, resolveActionCollection, type ActionCooldown, type ActionCost, type ActionDef, type ActionReason, type FocusDirection, type GridFocusOptions, type ResolvedAction, } from "./ui/actionModel.js";
+export { type GameLayoutMode, type GameViewportLayout, type HudPriority, type Insets, type LayoutCollision, type LayoutCollisionPolicy, type LayoutRect, type LayoutRegion, type MobileHudBehavior, } from "./ui/gameLayout.js";
+export { listHudPanelTypes, registerHudPanelType, resizePanelSize, resolveHudPanelLayout, type EditorUiDocument, type EditorUiPanelLayout, type HudResizeAxes, } from "./ui/hudDocument.js";
+export { HUD_ANCHOR_FRACTIONS, type HudAnchor, type HudLayoutStore, type HudPlacement, type HudSize, } from "./ui/hudLayout.js";
+export { hudScaleForViewport, overflowingPanels, resolveHudFit, type HudPlatform, type HudViewportConfig, } from "./ui/hudScale.js";
+export { orientationGateActive, orientationHintActive, resolveOrientationRequirement, type LayoutOrientation, } from "./ui/orientation.js";
+export { moveSelectionFocus, selectionWindow, summarizeSelection, type EntitySummaryDef, type EntityVital, type SelectionFocusDirection, type SelectionGroup, type SelectionView, type SelectionWindow, type SummarizeSelectionOptions, } from "./ui/selectionModel.js";
+export { swingTimerState, type SwingTargetInput } from "./ui/swingTimer.js";
+export { actionTooltip, placePopover, type PopoverOptions, type PopoverPlacement, type PopoverSide, type TooltipContent, type UiRect, type UiSize, } from "./ui/tooltipModel.js";

package/dist/ui.js

@@ -0,0 +1,15 @@
+export { formatDistance } from "./format/distance.js";
+export { formatDelta, formatDuration, formatOrdinal } from "./format/duration.js";
+export { formatSpeed } from "./format/speed.js";
+export { resolveGameLook } from "./render/lookPreset.js";
+export { STUDIO_STAGE_POST, } from "./render/postProcessing.js";
+export { BUILT_IN_SETTING_CATEGORIES, DEFAULT_GRAPHICS_QUALITY, DEFAULT_GRAPHICS_SHADOWS, DEFAULT_MASTER_VOLUME, DEFAULT_UI_SCALE, GRAPHICS_QUALITY_DPR, GRAPHICS_QUALITY_OPTIONS, SETTING_IDS, UI_SCALE_MAX, UI_SCALE_MIN, busVolumeSettingId, createSettingsStore, } from "./settings/settingsModel.js";
+export { actionByHotkey, actionCooldown, actionCooldownFromFraction, actionCost, moveGridFocus, resolveAction, resolveActionCollection, } from "./ui/actionModel.js";
+export {} from "./ui/gameLayout.js";
+export { listHudPanelTypes, registerHudPanelType, resizePanelSize, resolveHudPanelLayout, } from "./ui/hudDocument.js";
+export { HUD_ANCHOR_FRACTIONS, } from "./ui/hudLayout.js";
+export { hudScaleForViewport, overflowingPanels, resolveHudFit, } from "./ui/hudScale.js";
+export { orientationGateActive, orientationHintActive, resolveOrientationRequirement, } from "./ui/orientation.js";
+export { moveSelectionFocus, selectionWindow, summarizeSelection, } from "./ui/selectionModel.js";
+export { swingTimerState } from "./ui/swingTimer.js";
+export { actionTooltip, placePopover, } from "./ui/tooltipModel.js";

package/dist/visibility/bounds.d.ts

@@ -42,11 +42,17 @@ export type BoundsSpec = {
 };
 /** Conservative default: a unit sphere. Objects without explicit bounds cull as a small volume, never a point. */
 export declare const DEFAULT_BOUNDS: BoundsSpec;
+/** @internal */
 export declare function createRenderBounds(): RenderBounds;
-/** Resolve a spec + world position into concrete bounds. Writes into `out` when supplied (no allocation). */
+/** Resolve a spec + world position into concrete bounds. Writes into `out` when supplied (no allocation).
+ * @internal
+ */
 export declare function resolveBounds(spec: BoundsSpec, position: Vec3, out?: RenderBounds): RenderBounds;
+/** @internal */
 export declare function expandRenderBounds(bounds: RenderBounds, margin: number, out?: RenderBounds): RenderBounds;
+/** @internal */
 export declare function aabbIntersects(aMinX: number, aMinY: number, aMinZ: number, aMaxX: number, aMaxY: number, aMaxZ: number, bMinX: number, bMinY: number, bMinZ: number, bMaxX: number, bMaxY: number, bMaxZ: number): boolean;
+/** @internal */
 export declare function boundsIntersect(a: RenderBounds, b: RenderBounds): boolean;
 /**
  * BoundsSystem: caches resolved bounds per object and recomputes only when the caller's
@@ -63,4 +69,5 @@ export interface BoundsCache {
     size(): number;
     recomputes(): number;
 }
+/** @internal */
 export declare function createBoundsCache(): BoundsCache;

package/dist/visibility/bounds.js

@@ -1,5 +1,6 @@
 /** Conservative default: a unit sphere. Objects without explicit bounds cull as a small volume, never a point. */
 export const DEFAULT_BOUNDS = { kind: "sphere", radius: 1 };
+/** @internal */
 export function createRenderBounds() {
     return {
         centerX: 0,
@@ -27,7 +28,9 @@ function fillBounds(out, cx, cy, cz, hx, hy, hz) {
     out.radius = Math.sqrt(hx * hx + hy * hy + hz * hz);
     return out;
 }
-/** Resolve a spec + world position into concrete bounds. Writes into `out` when supplied (no allocation). */
+/** Resolve a spec + world position into concrete bounds. Writes into `out` when supplied (no allocation).
+ * @internal
+ */
 export function resolveBounds(spec, position, out = createRenderBounds()) {
     if (spec.kind === "point") {
         return fillBounds(out, position[0], position[1], position[2], 0, 0, 0);
@@ -49,6 +52,7 @@ export function resolveBounds(spec, position, out = createRenderBounds()) {
             return fillBounds(out, cx, cy, cz, spec.halfWidth, spec.halfHeight ?? 0, spec.halfDepth);
     }
 }
+/** @internal */
 export function expandRenderBounds(bounds, margin, out = createRenderBounds()) {
     out.centerX = bounds.centerX;
     out.centerY = bounds.centerY;
@@ -62,14 +66,17 @@ export function expandRenderBounds(bounds, margin, out = createRenderBounds()) {
     out.maxZ = bounds.maxZ + margin;
     return out;
 }
+/** @internal */
 export function aabbIntersects(aMinX, aMinY, aMinZ, aMaxX, aMaxY, aMaxZ, bMinX, bMinY, bMinZ, bMaxX, bMaxY, bMaxZ) {
     return (aMinX <= bMaxX && aMaxX >= bMinX &&
         aMinY <= bMaxY && aMaxY >= bMinY &&
         aMinZ <= bMaxZ && aMaxZ >= bMinZ);
 }
+/** @internal */
 export function boundsIntersect(a, b) {
     return aabbIntersects(a.minX, a.minY, a.minZ, a.maxX, a.maxY, a.maxZ, b.minX, b.minY, b.minZ, b.maxX, b.maxY, b.maxZ);
 }
+/** @internal */
 export function createBoundsCache() {
     const entries = new Map();
     let recomputes = 0;

package/dist/visibility/frustum.d.ts

@@ -36,12 +36,21 @@ export interface Frustum {
     maxY: number;
     maxZ: number;
 }
+/** @internal */
 export declare function createFrustum(): Frustum;
+/** @internal */
 export declare function updateFrustum(out: Frustum, view: CameraView): Frustum;
-/** Conservative AABB-vs-frustum: never a false negative (may keep a corner-case that is truly outside). */
+/** Conservative AABB-vs-frustum: never a false negative (may keep a corner-case that is truly outside).
+ * @internal
+ */
 export declare function aabbInFrustum(f: Frustum, minX: number, minY: number, minZ: number, maxX: number, maxY: number, maxZ: number): boolean;
+/** @internal */
 export declare function sphereInFrustum(f: Frustum, cx: number, cy: number, cz: number, radius: number): boolean;
-/** Sphere broad-phase reject, then the tight AABB test. Both conservative. */
+/** Sphere broad-phase reject, then the tight AABB test. Both conservative.
+ * @internal
+ */
 export declare function boundsInFrustum(f: Frustum, b: RenderBounds): boolean;
-/** Push every plane outward by `margin` (unit normals ⇒ d += margin) to form a preload/hysteresis region. */
+/** Push every plane outward by `margin` (unit normals ⇒ d += margin) to form a preload/hysteresis region.
+ * @internal
+ */
 export declare function dilateFrustum(src: Frustum, margin: number, out: Frustum): Frustum;

package/dist/visibility/frustum.js

@@ -1,5 +1,6 @@
 const WORLD_UP = [0, 1, 0];
 const ALT_UP = [1, 0, 0];
+/** @internal */
 export function createFrustum() {
     return {
         planes: new Float64Array(24),
@@ -43,6 +44,7 @@ function planeFromCorners(planes, slot, corners, a, b, c, centroidX, centroidY,
     planes[slot * 4 + 2] = nz;
     planes[slot * 4 + 3] = d;
 }
+/** @internal */
 export function updateFrustum(out, view) {
     const { position, target } = view;
     let fx = target[0] - position[0];
@@ -137,7 +139,9 @@ export function updateFrustum(out, view) {
     planeFromCorners(planes, 5, corners, 2, 3, 6, cX, cY, cZ); // bottom
     return out;
 }
-/** Conservative AABB-vs-frustum: never a false negative (may keep a corner-case that is truly outside). */
+/** Conservative AABB-vs-frustum: never a false negative (may keep a corner-case that is truly outside).
+ * @internal
+ */
 export function aabbInFrustum(f, minX, minY, minZ, maxX, maxY, maxZ) {
     const planes = f.planes;
     for (let i = 0; i < 6; i += 1) {
@@ -150,6 +154,7 @@ export function aabbInFrustum(f, minX, minY, minZ, maxX, maxY, maxZ) {
     }
     return true;
 }
+/** @internal */
 export function sphereInFrustum(f, cx, cy, cz, radius) {
     const planes = f.planes;
     for (let i = 0; i < 6; i += 1) {
@@ -159,13 +164,17 @@ export function sphereInFrustum(f, cx, cy, cz, radius) {
     }
     return true;
 }
-/** Sphere broad-phase reject, then the tight AABB test. Both conservative. */
+/** Sphere broad-phase reject, then the tight AABB test. Both conservative.
+ * @internal
+ */
 export function boundsInFrustum(f, b) {
     if (!sphereInFrustum(f, b.centerX, b.centerY, b.centerZ, b.radius))
         return false;
     return aabbInFrustum(f, b.minX, b.minY, b.minZ, b.maxX, b.maxY, b.maxZ);
 }
-/** Push every plane outward by `margin` (unit normals ⇒ d += margin) to form a preload/hysteresis region. */
+/** Push every plane outward by `margin` (unit normals ⇒ d += margin) to form a preload/hysteresis region.
+ * @internal
+ */
 export function dilateFrustum(src, margin, out) {
     const sp = src.planes;
     const op = out.planes;