@peekling/runtime 0.1.0 → 0.1.2

package/dist/runtime.js

@@ -1,21 +1,24 @@
 import { ContentRenderer } from "./content.js";
 import { InputCollector } from "./input.js";
+import { CharacterInteractionController, } from "./interaction.js";
 import { browserCompletionEvent, validateEventPayload } from "./events.js";
 import { directionTo } from "./direction.js";
 import { DiagnosticChannel } from "./diagnostics.js";
-import { EVENT_NAME_PATTERN } from "./contracts.js";
+import { EVENT_NAME_PATTERN, isSurfaceColor } from "./contracts.js";
 import { DEFAULT_MAX_DENSITY, DEFAULT_POSITION } from "./defaults.js";
 import { animationCycleMs, locomotionAdvance, locomotionSample, } from "./locomotion.js";
 import { loadNativePack, requiredAtlasDensity, } from "./loader.js";
 import { resolveCapabilityName } from "./normalized.js";
-import { PlanRuntime, compiledPlanSectionRequirements, createDefaultPlan, } from "./plan.js";
+import { PlanRuntime, compiledPlanSectionRequirements, createPresetPlan, } from "./plan.js";
 import { compilePlan } from "./plan-compiler.js";
 import { validateRuntimeConfiguration, validRuntimeName, } from "./runtime-validation.js";
 import { runtimeMessage } from "./runtime-diagnostics.js";
 import { OverrideManager, rejectedOverrideHandle } from "./overrides.js";
-import { AtlasRenderer } from "./renderer.js";
+import { createAtlasRenderer, } from "./renderer.js";
 import { resolveState } from "./resolver.js";
 import { SectionTracker } from "./sections.js";
+import { SvgPathSampler } from "./path-sampler.js";
+import { TargetTracker } from "./targets.js";
 import { registerSiteVisibility } from "./visibility.js";
 import { snapshotConfiguration } from "./own-data.js";
 import { NATIVE_DIRECTIONS, } from "./types.js";
@@ -23,6 +26,10 @@ const SUSPEND_HOST = 1;
 const SUSPEND_PAGE = 2;
 const SUSPEND_SITE = 4;
 const MAX_TIMER_DELAY = 2_147_483_647;
+const DEFAULT_GRAVITY = 1_800;
+const DEFAULT_THROW_SPEED = 1_800;
+const DEFAULT_BOUNCE = 0.35;
+const DEFAULT_FLOOR_INSET = 8;
 const EMPTY_CONTENT_SELECTIONS = Object.freeze([]);
 function browserSelectorIsValid(document, selector) {
     try {
@@ -86,10 +93,34 @@ function hatchOptions(input) {
     }
     return input;
 }
+function checkedIndicator(input) {
+    if (input === null)
+        return;
+    const value = snapshotConfiguration(input);
+    if (!value ||
+        typeof value !== "object" ||
+        Array.isArray(value) ||
+        (value.kind !== undefined &&
+            value.kind !== "dot" &&
+            value.kind !== "count") ||
+        typeof value.label !== "string" ||
+        value.label.length < 1 ||
+        value.label.length > 120 ||
+        /[\u0000-\u001f\u007f]/.test(value.label) ||
+        (value.count !== undefined &&
+            (!Number.isInteger(value.count) ||
+                value.count < 0 ||
+                value.count > 999)) ||
+        (value.color !== undefined && !isSurfaceColor(value.color)) ||
+        (value.visible !== undefined && typeof value.visible !== "boolean")) {
+        throw new TypeError(runtimeMessage("indicator.invalid", "Indicator is invalid"));
+    }
+    return value;
+}
 /** Package-internal implementation. It is not a supported import. */
 export class PeeklingRuntime {
-    static hatch(input) {
-        return new PeeklingRuntime(hatchOptions(input));
+    static hatch(input, rendererFactory = createAtlasRenderer) {
+        return new PeeklingRuntime(hatchOptions(input), rendererFactory);
     }
     /** Package-internal presentation update used only by the Web Component. */
     updateComponentName(value) {
@@ -128,7 +159,9 @@ export class PeeklingRuntime {
     #loaded;
     #renderer;
     #contentRenderer;
+    #interactionController;
     #sections;
+    #targets;
     #input;
     #raf = 0;
     #planTimer = 0;
@@ -164,10 +197,18 @@ export class PeeklingRuntime {
     #instanceId;
     #diagnostics;
     #styles;
+    #rendererFactory;
     #rejectedOverrideId = 0;
     #reportedNotReadyEvent = false;
     #reportedNotReadyOverride = false;
-    constructor(options = {}) {
+    #trackTargets = false;
+    #pathSampler;
+    #indicator;
+    #dragging = false;
+    #throwing = false;
+    #throwVelocity = { x: 0, y: 0 };
+    #landUntil = 0;
+    constructor(options = {}, rendererFactory = createAtlasRenderer) {
         options = snapshotConfiguration(options);
         const document = options.document ?? globalThis.document;
         const window = options.window ?? globalThis.window;
@@ -175,7 +216,10 @@ export class PeeklingRuntime {
             throw new Error(runtimeMessage("browser.context", "Browser document/window required"));
         this.#document = document;
         this.#window = window;
+        this.#pathSampler = new SvgPathSampler(document);
         this.#options = options;
+        this.#indicator = options.indicator;
+        this.#rendererFactory = rendererFactory;
         this.#now = window.performance?.now?.bind(window.performance) ?? Date.now;
         this.#instanceId = `instance:${Math.floor(this.#now())}:${Math.random().toString(36).slice(2, 8)}`;
         this.#diagnostics = new DiagnosticChannel({
@@ -293,6 +337,31 @@ export class PeeklingRuntime {
         this.#setSuspended(SUSPEND_HOST, false);
         this.#notice("lifecycle.resumed", "info", "lifecycle");
     }
+    refreshTargets() {
+        this.#targets?.refresh();
+    }
+    setIndicator(indicator) {
+        if (this.#destroyed)
+            return;
+        this.#indicator = checkedIndicator(indicator);
+        this.#interactionController?.updateIndicator(this.#indicator);
+    }
+    setContentVisible(visible) {
+        if (this.#destroyed || !this.#contentRenderer)
+            return false;
+        const expanded = this.#contentRenderer.setUserHidden(!visible);
+        this.#interactionController?.setExpanded(expanded);
+        this.#wake();
+        return expanded;
+    }
+    toggleContent() {
+        if (this.#destroyed || !this.#contentRenderer)
+            return false;
+        const expanded = this.#contentRenderer.toggleUserHidden();
+        this.#interactionController?.setExpanded(expanded);
+        this.#wake();
+        return expanded;
+    }
     destroy() {
         this.#destroy("destroyed");
     }
@@ -307,7 +376,9 @@ export class PeeklingRuntime {
         this.#input?.destroy();
         this.#plan?.reset();
         this.#sections?.destroy();
+        this.#targets?.destroy();
         this.#contentRenderer?.destroy();
+        this.#interactionController?.destroy();
         this.#renderer?.destroy();
         this.#unregisterVisibility?.();
         this.#unregisterVisibility = undefined;
@@ -334,10 +405,18 @@ export class PeeklingRuntime {
     async #initialize() {
         try {
             const validateSelector = (selector) => browserSelectorIsValid(this.#document, selector);
+            const targetIds = new Set(Object.keys(this.#options.targets ?? {}));
+            for (const selector of Object.values(this.#options.targets ?? {})) {
+                if (!validateSelector(selector)) {
+                    throw new TypeError(runtimeMessage("target.selector", "Target selector is invalid"));
+                }
+            }
             if (this.#options.plan !== undefined) {
                 compilePlan(this.#options.plan, {
                     contentIds: new Set(Object.keys(this.#content)),
+                    targets: targetIds,
                     validateSelector,
+                    validatePath: (path) => this.#pathSampler.validate(path),
                 });
             }
             const browserWindow = this.#window;
@@ -396,17 +475,22 @@ export class PeeklingRuntime {
             this.#loaded = loaded;
             const locomotion = hasLocomotion(loaded.content);
             const capabilities = new Set(locomotion ? ["locomotion"] : []);
-            const compiled = compilePlan(this.#options.plan ?? createDefaultPlan(locomotion), {
+            const compiled = compilePlan(this.#options.plan ??
+                createPresetPlan(this.#options.preset ?? "companion", locomotion), {
                 states: new Set(Object.keys(loaded.content.states)),
                 capabilities,
                 contentIds: new Set(Object.keys(this.#content)),
+                targets: targetIds,
                 validateSelector,
+                validatePath: (path) => this.#pathSampler.validate(path),
             });
             this.#plan = new PlanRuntime(compiled);
             this.#overrides = new OverrideManager({
                 states: new Set(Object.keys(loaded.content.states)),
                 capabilities,
                 contentIds: new Set(Object.keys(this.#content)),
+                targets: targetIds,
+                validatePath: (path) => this.#pathSampler.validate(path),
             }, this.#now, (message) => this.#diagnose(message, "override.rejected", "warning", "override"));
             if (this.#displayName === "") {
                 this.#displayName = loaded.content.displayName;
@@ -425,16 +509,53 @@ export class PeeklingRuntime {
             this.#position = resolveInitialPosition(this.#options.position ?? DEFAULT_POSITION, this.#window.innerWidth, this.#window.innerHeight, (loaded.content.atlas.logicalWidth ?? loaded.content.atlas.cellWidth) *
                 scale, (loaded.content.atlas.logicalHeight ??
                 loaded.content.atlas.cellHeight) * scale);
-            this.#renderer = new AtlasRenderer(this.#document, loaded.content, loaded.atlasObjectUrl, scale, this.#styles);
+            this.#renderer = this.#rendererFactory({
+                document: this.#document,
+                pack: loaded.content,
+                atlasUrl: loaded.atlasObjectUrl,
+                scale,
+                styles: this.#styles,
+            });
             if (Object.keys(this.#content).length ||
                 this.#displayName !== undefined) {
                 this.#ensureContentRenderer();
             }
+            if (this.#options.interaction !== false) {
+                const interaction = this.#options.interaction ?? {};
+                const pressAction = interaction.press ??
+                    (interaction.pressEvent ? "emit" : "toggle-content");
+                const controlsContent = Boolean(this.#contentRenderer) &&
+                    (pressAction === "toggle-content" ||
+                        pressAction === "show-content" ||
+                        pressAction === "hide-content");
+                if (interaction.contentInitiallyHidden) {
+                    this.#contentRenderer?.setUserHidden(true);
+                }
+                this.#interactionController = new CharacterInteractionController({
+                    document: this.#document,
+                    styles: this.#styles,
+                    label: interaction.label ??
+                        `Interact with ${loaded.content.displayName || "Peekling"}`,
+                    draggable: interaction.drag !== false,
+                    ...(controlsContent
+                        ? { expanded: !interaction.contentInitiallyHidden }
+                        : {}),
+                    ...(this.#indicator ? { indicator: this.#indicator } : {}),
+                    onPress: () => this.#handleCharacterPress(),
+                    onDragStart: () => this.#startCharacterDrag(),
+                    onDragMove: (position, velocity) => this.#moveCharacterDrag(position, velocity),
+                    onDragEnd: (velocity, moved, pointer) => this.#endCharacterDrag(velocity, moved, pointer),
+                });
+                if (interaction.contentInitiallyHidden) {
+                    this.#interactionController.setExpanded(false);
+                }
+            }
             try {
                 await Promise.all([
                     this.#visibilityReady,
                     this.#renderer.ready,
                     this.#contentRenderer?.ready,
+                    this.#interactionController?.ready,
                 ]);
             }
             catch (cause) {
@@ -443,10 +564,14 @@ export class PeeklingRuntime {
             }
             const requirements = compiledPlanSectionRequirements(compiled);
             this.#createInput();
+            if (targetIds.size) {
+                this.#targets = new TargetTracker(this.#document, this.#window, this.#options.targets, () => this.#wake());
+            }
             if (requirements.selectors.length) {
                 this.#sections = new SectionTracker(this.#document, this.#window, requirements.selectors, requirements.thresholds, () => this.#wake(), (fact) => this.#input?.captureReaction("section.visibility", fact, "browser"));
             }
             this.#renderer.setHidden(this.#siteHidden);
+            this.#interactionController?.setHidden(this.#siteHidden);
             if (this.#suspensions) {
                 this.#input?.setSuspended(true);
                 this.#sections?.setSuspended(true);
@@ -517,6 +642,122 @@ export class PeeklingRuntime {
         });
         return this.#contentRenderer;
     }
+    #handleCharacterPress() {
+        if (this.#destroyed)
+            return;
+        const interaction = this.#options.interaction || {};
+        if (interaction.clearIndicatorOnPress === true && this.#indicator) {
+            this.setIndicator(null);
+        }
+        const action = interaction.press ?? (interaction.pressEvent ? "emit" : "toggle-content");
+        if (action === "emit") {
+            if (interaction.pressEvent)
+                this.emit(interaction.pressEvent);
+            return;
+        }
+        if (action === "none")
+            return;
+        if (action === "show-content")
+            this.setContentVisible(true);
+        else if (action === "hide-content")
+            this.setContentVisible(false);
+        else
+            this.toggleContent();
+    }
+    #startCharacterDrag() {
+        if (this.#destroyed || this.#siteHidden)
+            return;
+        this.#dragging = true;
+        this.#throwing = false;
+        this.#landUntil = 0;
+        this.#throwVelocity = { x: 0, y: 0 };
+        this.#wake();
+    }
+    #moveCharacterDrag(position, velocity) {
+        if (!this.#dragging || this.#destroyed)
+            return;
+        const size = this.#characterSize();
+        this.#position = size
+            ? clampPosition(position, { width: this.#window.innerWidth, height: this.#window.innerHeight }, size.width, size.height)
+            : { ...position };
+        this.#throwVelocity = { ...velocity };
+        this.#wake();
+    }
+    #endCharacterDrag(velocity, moved, pointer) {
+        if (!this.#dragging || this.#destroyed)
+            return;
+        this.#dragging = false;
+        if (!moved) {
+            this.#throwVelocity = { x: 0, y: 0 };
+            this.#wake();
+            return;
+        }
+        const interaction = this.#options.interaction || {};
+        if (interaction.catchTarget &&
+            this.#targets?.contains(interaction.catchTarget, pointer, interaction.catchMargin ?? 24) &&
+            this.#catchCharacter(interaction.catchTarget)) {
+            return;
+        }
+        if (this.#reducedMotion) {
+            this.#landCharacter();
+            return;
+        }
+        if (interaction.throw === false) {
+            this.#throwVelocity = { x: 0, y: 0 };
+            this.#wake();
+            return;
+        }
+        const maximum = interaction.maxThrowSpeed ?? DEFAULT_THROW_SPEED;
+        const magnitude = Math.hypot(velocity.x, velocity.y);
+        const factor = magnitude > maximum && magnitude ? maximum / magnitude : 1;
+        this.#throwVelocity = {
+            x: velocity.x * factor,
+            y: velocity.y * factor,
+        };
+        this.#throwing = true;
+        this.#wake();
+    }
+    #characterSize() {
+        const loaded = this.#loaded?.content;
+        if (!loaded)
+            return;
+        const scale = this.#options.scale ?? loaded.defaultScale;
+        return {
+            width: (loaded.atlas.logicalWidth ?? loaded.atlas.cellWidth) * scale,
+            height: (loaded.atlas.logicalHeight ?? loaded.atlas.cellHeight) * scale,
+        };
+    }
+    #landCharacter() {
+        const size = this.#characterSize();
+        if (size) {
+            const floorInset = (this.#options.interaction || {}).floorInset ?? DEFAULT_FLOOR_INSET;
+            this.#position = clampPosition({
+                x: this.#position.x,
+                y: this.#window.innerHeight - size.height / 2 - floorInset,
+            }, { width: this.#window.innerWidth, height: this.#window.innerHeight }, size.width, size.height);
+        }
+        this.#dragging = false;
+        this.#throwing = false;
+        this.#throwVelocity = { x: 0, y: 0 };
+        this.#landUntil = this.#now() + 360;
+        this.#wake();
+    }
+    #catchCharacter(targetId) {
+        const target = this.#targets?.snapshot(true)[targetId];
+        const size = this.#characterSize();
+        if (!target || !size)
+            return false;
+        const interaction = this.#options.interaction || {};
+        const point = characterTargetPoint(target, interaction.catchAnchor ?? "center", size);
+        this.#position = clampPosition(point, { width: this.#window.innerWidth, height: this.#window.innerHeight }, size.width, size.height);
+        this.#throwing = false;
+        this.#throwVelocity = { x: 0, y: 0 };
+        this.#landUntil = this.#now() + 360;
+        if (interaction.catchEvent)
+            this.emit(interaction.catchEvent);
+        this.#wake();
+        return true;
+    }
     #diagnose(message, code = "runtime.notice", severity = "warning", phase = "internal", eventId, metadata, cause) {
         this.#diagnostics.emit({
             code,
@@ -591,6 +832,7 @@ export class PeeklingRuntime {
             return;
         this.#siteHidden = hidden;
         this.#renderer?.setHidden(hidden);
+        this.#interactionController?.setHidden(hidden);
         if (this.#destroyed)
             return;
         if (hidden && this.#contentRenderer) {
@@ -602,6 +844,9 @@ export class PeeklingRuntime {
                 return;
         }
         if (hidden) {
+            this.#dragging = false;
+            this.#throwing = false;
+            this.#throwVelocity = { x: 0, y: 0 };
             this.#overrides?.clear("dismissed");
             this.#setSuspended(SUSPEND_SITE, true);
             this.#notice("lifecycle.dismissed", "info", "lifecycle");
@@ -717,8 +962,13 @@ export class PeeklingRuntime {
             .upgrade(required)
             .then((changed) => {
             if (changed && !this.#destroyed && this.#loaded === loaded) {
-                this.#renderer?.swapAtlas(loaded.content, loaded.atlasObjectUrl);
-                this.#wake();
+                const renderer = this.#renderer;
+                if (!renderer)
+                    return;
+                return Promise.resolve(renderer.swapAtlas(loaded.content, loaded.atlasObjectUrl)).then(() => {
+                    if (!this.#destroyed && this.#loaded === loaded)
+                        this.#wake();
+                });
             }
         })
             .catch((error) => {
@@ -795,10 +1045,13 @@ export class PeeklingRuntime {
             pointer: input.pointer,
             position: this.#position,
             viewport,
+            characterSize,
             lastActivityAt: input.lastActivityAt,
             reducedMotion: this.#reducedMotion,
             pageVisible: !this.#document.hidden,
             sections,
+            targets: this.#targets?.snapshot(this.#trackTargets),
+            samplePath: (path, progress) => this.#pathSampler.sample(path, progress),
             reaction,
         };
         return {
@@ -822,6 +1075,7 @@ export class PeeklingRuntime {
             overrides.observeEvent(reaction.name, reaction.source);
         }
         const request = overrides.compose(ordinary, world);
+        this.#trackTargets = request.motion?.trackTarget === true;
         if (this.#reducedMotion) {
             delete request.motion;
             if (request.capability === "locomotion")
@@ -829,6 +1083,25 @@ export class PeeklingRuntime {
             if (!request.state)
                 request.state = "idle";
         }
+        const interaction = this.#options.interaction || {};
+        if (this.#dragging) {
+            delete request.motion;
+            delete request.capability;
+            request.state = interaction.dragState ?? "scroll:fly";
+        }
+        else if (this.#throwing) {
+            delete request.motion;
+            delete request.capability;
+            request.state =
+                this.#throwVelocity.y < 0
+                    ? (interaction.riseState ?? "scroll:fly")
+                    : (interaction.fallState ?? "scroll:fall");
+        }
+        else if (this.#landUntil > world.now) {
+            delete request.motion;
+            delete request.capability;
+            request.state = interaction.landState ?? "success";
+        }
         const diagnostics = [];
         if (reaction) {
             this.#seenReaction = reaction.id;
@@ -873,18 +1146,71 @@ export class PeeklingRuntime {
         }
         return this.#frameActive(frame);
     }
+    #advanceThrow(snapshot) {
+        if (!this.#throwing)
+            return;
+        const interaction = this.#options.interaction || {};
+        const dt = snapshot.frame.stepMs / 1_000;
+        const bounce = interaction.bounce ?? DEFAULT_BOUNCE;
+        const halfWidth = snapshot.characterSize.width / 2;
+        const halfHeight = snapshot.characterSize.height / 2;
+        const floor = snapshot.world.viewport.height -
+            halfHeight -
+            (interaction.floorInset ?? DEFAULT_FLOOR_INSET);
+        let velocityX = this.#throwVelocity.x;
+        let velocityY = this.#throwVelocity.y + (interaction.gravity ?? DEFAULT_GRAVITY) * dt;
+        let x = this.#position.x + velocityX * dt;
+        let y = this.#position.y + velocityY * dt;
+        const right = snapshot.world.viewport.width - halfWidth;
+        if (x < halfWidth) {
+            x = halfWidth;
+            velocityX = Math.abs(velocityX) * bounce;
+        }
+        else if (x > right) {
+            x = right;
+            velocityX = -Math.abs(velocityX) * bounce;
+        }
+        if (y < halfHeight) {
+            y = halfHeight;
+            velocityY = Math.abs(velocityY) * bounce;
+        }
+        const next = { x, y };
+        if (interaction.catchTarget &&
+            this.#targets?.contains(interaction.catchTarget, next, interaction.catchMargin ?? 24) &&
+            this.#catchCharacter(interaction.catchTarget)) {
+            return;
+        }
+        if (y >= floor) {
+            this.#position = { x, y: floor };
+            this.#landCharacter();
+            return;
+        }
+        this.#position = next;
+        this.#throwVelocity = { x: velocityX * 0.995, y: velocityY };
+    }
     #calculatePresentation(snapshot, evaluation) {
         const { frame, characterSize, world } = snapshot;
         const { request } = evaluation;
         const loaded = frame.loaded.content;
         if (!this.#reducedMotion)
             this.#animationClock += Math.max(0, frame.elapsed);
+        this.#advanceThrow(snapshot);
         const requested = request.capability === "locomotion" && request.motion
             ? loaded.directionalStates?.[directionTo({ x: 0, y: 0 }, { x: request.motion.x, y: request.motion.y })]
             : resolveCapabilityName(request.state, loaded);
         const resolved = resolveState(requested, loaded.states);
         let lift = 0;
-        if (request.motion) {
+        if (request.motion?.direct) {
+            const distance = request.motion.maxDistance ?? 0;
+            this.#position = clampPosition({
+                x: this.#position.x + request.motion.x * distance,
+                y: this.#position.y + request.motion.y * distance,
+            }, world.viewport, characterSize.width, characterSize.height);
+            lift = request.motion.lift ?? 0;
+            this.#locomotionState = "";
+            this.#locomotionElapsed = 0;
+        }
+        else if (request.motion) {
             if (this.#locomotionState !== resolved.name) {
                 this.#locomotionState = resolved.name;
                 this.#locomotionElapsed = 0;
@@ -904,8 +1230,9 @@ export class PeeklingRuntime {
                 y: this.#position.y + request.motion.y * distance,
             }, world.viewport, characterSize.width, characterSize.height);
             lift =
-                locomotionSample(loaded.locomotionMotion, nextCycles).lift *
-                    characterSize.height;
+                request.motion.lift ??
+                    locomotionSample(loaded.locomotionMotion, nextCycles).lift *
+                        characterSize.height;
         }
         else {
             this.#locomotionState = "";
@@ -932,12 +1259,18 @@ export class PeeklingRuntime {
         if (!this.#frameActive(frame))
             return;
         frame.renderer.render(presentation.state, this.#animationClock, this.#position, snapshot.devicePixelRatio, presentation.lift);
+        if (!this.#frameActive(frame))
+            return;
+        this.#interactionController?.render(this.#position, snapshot.characterSize, presentation.lift);
         if (!this.#frameActive(frame))
             return;
         this.#lastTick = frame.now;
         this.#schedulePlan(frame);
         if (this.#frameActive(frame) &&
-            (evaluation.request.motion || frame.input.reaction))
+            (evaluation.request.motion ||
+                frame.input.reaction ||
+                this.#throwing ||
+                this.#dragging))
             this.#wake();
     }
     #endPage() {
@@ -1013,3 +1346,21 @@ function clampPosition(point, viewport, width, height) {
         y: Math.max(height / 2, Math.min(viewport.height - height / 2, point.y)),
     };
 }
+function characterTargetPoint(target, anchor, character) {
+    const center = {
+        x: target.left + target.width / 2,
+        y: target.top + target.height / 2,
+    };
+    switch (anchor) {
+        case "top":
+            return { x: center.x, y: target.top - character.height / 2 };
+        case "right":
+            return { x: target.right + character.width / 2, y: center.y };
+        case "bottom":
+            return { x: center.x, y: target.bottom + character.height / 2 };
+        case "left":
+            return { x: target.left - character.width / 2, y: center.y };
+        default:
+            return center;
+    }
+}

package/dist/targets.d.ts

@@ -0,0 +1,11 @@
+import type { Point, TargetSnapshot } from "./types.js";
+/** Tracks host-approved geometry without moving, styling, or reparenting host DOM. */
+export declare class TargetTracker {
+    #private;
+    constructor(document: Document, window: Window, selectors: Readonly<Record<string, string>>, wake: () => void);
+    snapshot(force?: boolean): Readonly<Record<string, TargetSnapshot>>;
+    contains(id: string, point: Readonly<Point>, margin?: number): boolean;
+    refresh: () => void;
+    destroy(): void;
+}
+//# sourceMappingURL=targets.d.ts.map

package/dist/targets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"targets.d.ts","sourceRoot":"","sources":["../src/targets.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAIxD,sFAAsF;AACtF,qBAAa,aAAa;;IAYxB,YACE,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAC3C,IAAI,EAAE,MAAM,IAAI,EAwBjB;IAED,QAAQ,CAAC,KAAK,UAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,CAwChE;IAED,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,SAAI,GAAG,OAAO,CAShE;IAED,OAAO,QAAO,IAAI,CAIhB;IAEF,OAAO,IAAI,IAAI,CAQd;CAGF"}