@atolljs/islands 0.1.12 → 0.1.14

package/dist/worker/dom/resizeObserver.d.ts

@@ -0,0 +1,29 @@
+/**
+ * A `ResizeObserver` over the pushed-measure channel — the class
+ * `globalThis.ResizeObserver`/`window.ResizeObserver` resolve to inside an
+ * island instance. Each `observe(el)` registers a `doc.observeSize`
+ * subscription (which emits the `measure` op once per element); each pushed
+ * rect invokes the callback with a single-entry batch, matching how real RO
+ * delivers per-element observations (the driver already batches the wire
+ * push, the DOM API just doesn't promise same-batch grouping).
+ *
+ * Entries carry the fields layout libraries read: `target`, `contentRect`
+ * (the measured box), and `borderBoxSize`/`contentBoxSize`/`devicePixelContentBoxSize`
+ * arrays (echarts zrender, recharts' ResponsiveContainer, and RO-polyfill-
+ * style code paths). Box options are accepted but ignored — the channel
+ * delivers one box and it answers both reads.
+ *
+ * No doc resolvable (module-scope or post-unmount construction) means there
+ * is nothing that could ever be measured — observe() silently no-ops rather
+ * than pinning a foreign document, the same resolution rule the
+ * `document`/`window` global dispatchers use.
+ */
+export declare class ProxyResizeObserver {
+    private readonly _callback;
+    /** proxy el → the observeSize detacher (unobserve/disconnect paths). */
+    private readonly _targets;
+    constructor(callback: ResizeObserverCallback);
+    observe(target: unknown, _options?: ResizeObserverOptions): void;
+    unobserve(target: unknown): void;
+    disconnect(): void;
+}

package/dist/worker/dom/selectors.d.ts

@@ -0,0 +1,17 @@
+import { ProxyElement } from './element.js';
+interface CompoundSelector {
+    tag?: string;
+    id?: string;
+    classes: string[];
+    attrs: Array<{
+        name: string;
+        value?: string;
+    }>;
+}
+export declare function parseCompound(part: string, sel: string): CompoundSelector;
+export declare function parseSelector(selector: string): CompoundSelector[];
+export declare function matchCompound(el: ProxyElement, c: CompoundSelector): boolean;
+/** `el` matches the last compound; each earlier compound must match some
+ *  ancestor above the previous match — the descendant combinator. */
+export declare function matchesChain(el: ProxyElement, chain: CompoundSelector[]): boolean;
+export {};

package/dist/worker/dom/window.d.ts

@@ -0,0 +1,80 @@
+import { type ProxyDocument } from './document.js';
+import { ProxyResizeObserver } from './resizeObserver.js';
+import { type ProxyEventHandler } from './node.js';
+/** What installDomShim puts on globalThis.window — a facade OBJECT, not
+ *  globalThis itself (the pool's message channel lives on self). */
+export interface WindowShim {
+    document: ProxyDocument;
+    navigator: {
+        userAgent: string;
+    };
+    location: {
+        href: string;
+        reload(): void;
+        assign(url: string): void;
+        replace(url: string): void;
+    };
+    innerWidth: number;
+    innerHeight: number;
+    devicePixelRatio: number;
+    requestAnimationFrame(cb: (time: number) => void): number;
+    cancelAnimationFrame(id?: number): void;
+    setTimeout(callback: (...args: unknown[]) => void, delay?: number, ...args: unknown[]): number;
+    clearTimeout(id?: number): void;
+    setInterval(callback: (...args: unknown[]) => void, delay?: number, ...args: unknown[]): number;
+    clearInterval(id?: number): void;
+    getComputedStyle(el: unknown): Record<string, never>;
+    /** ResizeObserver over the pushed-measure channel — observe() registers
+     *  a doc.observeSize subscription, pushed rects arrive as entries. */
+    ResizeObserver: typeof ProxyResizeObserver;
+    /** Media queries can't be answered worker-side — always `matches: false`. */
+    matchMedia(query: string): MediaQueryList;
+    addEventListener(type: string, fn: ProxyEventHandler, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener(type: string, fn: ProxyEventHandler, options?: boolean | EventListenerOptions): void;
+    /** Scrolling is main-thread business — no-ops so window.scrollTo(x,y)
+     *  calls in libraries don't throw. */
+    scrollTo(x?: number | ScrollToOptions, y?: number): void;
+    scrollBy(x?: number | ScrollToOptions, y?: number): void;
+    scroll(x?: number | ScrollToOptions, y?: number): void;
+}
+export interface WindowFacadeBundle {
+    facade: WindowShim;
+    /** Detach every surviving window listener — ops and handler-table entries. */
+    teardown(): void;
+}
+export declare function installInstanceDispatcher(): void;
+/**
+ * Install this document as the instance's DOM surface — the entry point for
+ * running real DOM-dependent libraries unmodified inside an island instance:
+ *
+ *   const doc = createProxyDocument(instance);
+ *   installDomShim(doc);
+ *   SomeVendorLib.mount(doc.body);  // uses document./window./innerHTML…
+ *
+ * Under the instance dispatcher (installed here automatically, and by
+ * definePolyWorker for every island worker) `globalThis.document` and
+ * `globalThis.window` already resolve to this document while its instance is
+ * active — so this call's real work is building the window facade
+ * (navigator/location stubs, timers + rAF passthrough, innerWidth/Height
+ * from the pushed container size, empty getComputedStyle, never-matching
+ * matchMedia, addEventListener wired to `listen` ops on id 0) and exposing
+ * it as `document.defaultView`.
+ *
+ * It also pins the CLASS globals (`Node`/`Text`/`Comment` → the proxy
+ * classes; `HTMLMediaElement`/`customElements` → never-match stubs) for
+ * framework feature probes — the instance dispatcher resolves them
+ * ambiently anyway, so the assignment makes this document's install
+ * explicit and restores the previous values on uninstall.
+ *
+ * What does NOT get touched — deliberately:
+ *  - `globalThis.addEventListener`/`removeEventListener` and `self` — the
+ *    pool's `self.onmessage` channel lives there; `window` is a facade
+ *    object, not the global.
+ *  - Any other global (history, fetch, localStorage…) — libraries touching
+ *    them fail loudly, which is the honest answer.
+ *
+ * Returns `uninstall()` tearing down the facade's listeners. Also runs
+ * automatically on `doc.dispose()` (the updateProps rebuild path) and is
+ * superseded by a later installDomShim call — the last install wins.
+ */
+export declare function installDomShim(doc: ProxyDocument): () => void;

package/dist/worker/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The worker-side surface of @atolljs/islands — import from
+ * '@atolljs/islands/worker' inside the worker entry:
+ *
+ *   import { definePolyWorker } from '@atolljs/islands/worker';
+ *   export const renderWorker = definePolyWorker({ apps: { ... } });
+ *
+ * Framework apps also use from here: `emit` (island→shell
+ * channel), `runInInstance` (instance scoping for worker-initiated work),
+ * `createProxyDocument`/`installDomShim` (imperative DOM), plus the
+ * renderer-facing instance factories (`newElement`/`newText`/`serializeProps`,
+ * `ROOT_CONTAINER`) the `*-island` worker adapters drive.
+ *
+ * Framework-neutral by construction: this entry imports no framework — React's
+ * reconciler adapter lives in `@atolljs/react-island/worker`.
+ */
+export { definePolyWorker, defineMonoWorker } from './defineWorkers.js';
+export type { ImperativeIslandApp, Instance, IslandApp, PolyWorkerRegistry, RenderContext, RenderedHandle, RenderedIslandApp, } from './defineWorkers.js';
+export { islandApp, islandAppNameOf } from '../app.js';
+export { defineIslandContract, isIslandContract, withContract, contractOf } from '../contract.js';
+export type { IslandContract, IslandContractEventHandler, IslandContractEvents, IslandContractProps, } from '../contract.js';
+export { allocId, bumpOpsVersion, emit, getActiveInstance, getHandler, getLastActiveInstance, getLastTouchedInstance, getInstanceSize, instances, newElement, newText, proxyInstanceStats, pushOp, registerHandler, ROOT_CONTAINER, runInInstance, serializeProps, setActiveInstance, setDoorbellContract, setInstanceSize, takeOps, unregisterHandler, } from './instance.js';
+export type { ElementInstance, HostInstance, RootContainer, TextInstance } from './instance.js';
+export { createProxyDocument, installDomShim, installInstanceDispatcher, ProxyComment, ProxyElement, ProxyFragment, ProxyNode, ProxyResizeObserver, ProxyText, docForInstance, } from './proxyDom.js';
+export type { AdjacentPosition, InternalDocument, ProxyClassList, ProxyDocument, ProxyEventHandler, WindowShim, WireListenerOpts, } from './proxyDom.js';
+export type { EventPayload, IslandWorkerMethods, MeasuredRect, Op, WireProps } from '../ops.js';
+export { isEventRef } from '../ops.js';
+export { renderMemory } from '../memory.js';
+export type { DoorbellSpec } from '../memory.js';
+export { mountSubIsland } from './subIsland.js';
+export type { MountSubIslandOptions, SubIslandHandle } from './subIsland.js';
+export { connectIslandWorker, mountIsland } from '../island.js';
+export type { ConnectIslandWorkerConfig, IslandClient, IslandHandle, Mode, MountIslandOptions, } from '../island.js';