playhtml 2.11.0 → 2.11.2

package/dist/main.d.ts

@@ -1,24 +1,41 @@
-import { Cursor } from '../../common/src';
-import { CursorEvents } from '../../../common/src';
-import { CursorPresence } from '../../common/src';
-import { CursorPresenceView } from '../../../common/src';
+import { CanDuplicateTo } from "@playhtml/common";
+import { CanMoveBounds } from "@playhtml/common";
+import { CanMoveBoundsMinVisible } from "@playhtml/common";
+import { CanMoveBoundsMinVisiblePx } from "@playhtml/common";
+import { Cursor } from "@playhtml/common";
+import { CursorEvents } from "@playhtml/common";
+import { CursorEvents as CursorEvents_2 } from "@playhtml/common";
+import { CursorPresence } from "@playhtml/common";
+import { CursorPresenceView } from "@playhtml/common";
+import { CursorPresenceView as CursorPresenceView_2 } from "@playhtml/common";
 import { default as default_2 } from 'y-partyserver/provider';
-import { ElementAwarenessEventHandlerData } from '../../common/src';
-import { ElementData } from '../../common/src';
-import { ElementEventHandlerData } from '../../common/src';
-import { ElementInitializer } from '../../common/src';
-import { ElementSetupData } from '../../common/src';
-import { EventMessage } from '../../common/src';
-import { MappedTypeDescription } from 'node_modules/@syncedstore/core/types/doc';
-import { ModifierKey } from '../../common/src';
-import { PageDataChannel } from '../../common/src';
-import { PlayerIdentity } from '../../common/src';
-import { PlayerIdentity as PlayerIdentity_2 } from '../../../common/src';
-import { PlayEvent } from '../../common/src';
-import { PresenceAPI } from '../../common/src';
-import { PresenceRoom } from '../../common/src';
-import { RegisteredPlayEvent } from '../../common/src';
-import { TagType } from '../../common/src';
+import { ElementAwarenessEventHandlerData } from "@playhtml/common";
+import { ElementData } from "@playhtml/common";
+import { ElementEventHandlerData } from "@playhtml/common";
+import { ElementInitializer } from "@playhtml/common";
+import { ElementSetupData } from "@playhtml/common";
+import { EventMessage } from "@playhtml/common";
+import { getIdForElement } from "@playhtml/common";
+import { ModifierKey } from "@playhtml/common";
+import { PageDataChannel } from "@playhtml/common";
+import { PlayerIdentity } from "@playhtml/common";
+import { PlayerIdentity as PlayerIdentity_2 } from "@playhtml/common";
+import { PlayEvent } from "@playhtml/common";
+import { PresenceAPI } from "@playhtml/common";
+import { PresenceRoom } from "@playhtml/common";
+import { PresenceServerMessage } from "@playhtml/common";
+import { PresenceView } from "@playhtml/common";
+import { RegisteredPlayEvent } from "@playhtml/common";
+import { TagType } from "@playhtml/common";
+import { TagTypeToElement } from "@playhtml/common";
+
+export { CanDuplicateTo }
+
+export { CanMoveBounds }
+
+export { CanMoveBoundsMinVisible }
+
+export { CanMoveBoundsMinVisiblePx }
 
 declare function createPageData<T>(name: string, defaultValue: T): PageDataChannel<T>;
 
@@ -29,14 +46,19 @@ export { Cursor }
 declare class CursorClientAwareness {
     private provider;
     private options;
+    private presenceTransport?;
     private cursors;
     private cursorAnimators;
     private spatialGrid;
     private proximityUsers;
     private currentCursor;
     private playerIdentity;
-    private updateThrottled;
+    private awarenessUpdateTimeout;
     private lastUpdate;
+    private pointerFrame;
+    private pendingPointerSample;
+    private cursorEventCleanups;
+    private ownCursorSvgCache;
     private visibilityThreshold;
     private isStylesAdded;
     private globalApiListeners;
@@ -45,8 +67,13 @@ declare class CursorClientAwareness {
     private chat;
     private currentMessage;
     private otherUsersWithMessages;
+    private lastSentMessage;
     private cursorPresenceChangeCallbacks;
     private coordinateMode;
+    private presenceStore;
+    private presenceTransportUnsubscribe;
+    private presenceExpiryInterval;
+    private serverCursorMaxHz;
     private getContainerMatrix;
     private clientToStorage;
     private storageToClient;
@@ -57,12 +84,22 @@ declare class CursorClientAwareness {
     private lastKnownContainer;
     private clientIdToStableId;
     private pendingRemovals;
-    constructor(provider: default_2, options?: CursorOptions);
+    constructor(provider: default_2, options?: CursorOptions, presenceTransport?: CursorPresenceTransport | undefined);
     private initialize;
     private setupAwarenessHandling;
+    private setupPresenceTransportHandling;
+    private handlePresenceTransportMessage;
+    private handlePresenceRate;
+    private startPresenceExpiryTimer;
+    private removeExpiredPresenceCursors;
+    private renderPresenceStore;
+    private refreshPresenceTransportColors;
     private syncExistingAwareness;
     private handleAwarenessChange;
     private hasOtherClientForStableId;
+    private cursorPresenceEntries;
+    private activeCursorPresenceEntries;
+    private isFreshCursorPresence;
     private rebuildSpatialGrid;
     private checkProximityOptimized;
     private addCursorStyles;
@@ -70,10 +107,19 @@ declare class CursorClientAwareness {
     private resolveTargetCoords;
     private applyZoneStyling;
     private hitTestZones;
+    private getOwnCursorSvg;
+    private addCursorEventListener;
+    private requestPointerFrame;
+    private cancelPointerFrame;
+    private queuePointerSample;
+    private processPointerSample;
     private setupCursorTracking;
     private repositionAllCursors;
-    private throttledUpdateCursorAwareness;
+    private snapCursorToPresence;
+    private getActiveCursorConnectionCount;
+    private scheduleCursorAwarenessUpdate;
     private updateCursorAwareness;
+    private publishPresenceTransportState;
     private getContainer;
     refreshContainer(): void;
     refreshCursorStyles(): void;
@@ -98,6 +144,7 @@ declare class CursorClientAwareness {
     private updateAllCursorVisibility;
     private showAllCursors;
     configure(options: Partial<CursorOptions>): void;
+    private publishPlayerIdentity;
     registerZone(element: HTMLElement, options?: CursorZoneOptions): void;
     unregisterZone(elementId: string): void;
     hideCursor(connectionId: string): void;
@@ -108,13 +155,13 @@ declare class CursorClientAwareness {
         gridCells: number;
         avgCursorsPerCell: number;
     };
-    on<K extends keyof CursorEvents>(event: K, callback: (value: CursorEvents[K]) => void): void;
-    off<K extends keyof CursorEvents>(event: K, callback: (value: CursorEvents[K]) => void): void;
-    getSnapshot(): CursorEvents;
+    on<K extends keyof CursorEvents_2>(event: K, callback: (value: CursorEvents_2[K]) => void): void;
+    off<K extends keyof CursorEvents_2>(event: K, callback: (value: CursorEvents_2[K]) => void): void;
+    getSnapshot(): CursorEvents_2;
     getMyPlayerIdentity(): PlayerIdentity_2;
     getProvider(): default_2;
-    getCursorPresences(): Map<string, CursorPresenceView>;
-    onCursorPresencesChange(callback: (presences: Map<string, CursorPresenceView>) => void): () => void;
+    getCursorPresences(): Map<string, CursorPresenceView_2>;
+    onCursorPresencesChange(callback: (presences: Map<string, CursorPresenceView_2>) => void): () => void;
     private notifyCursorPresenceListeners;
     /**
      * Apply a CSS class to a specific cursor element identified by the player's stableId (publicKey).
@@ -129,6 +176,8 @@ export declare type CursorContainer = HTMLElement | string | (() => HTMLElement
 
 export declare type CursorCoordinateMode = "relative" | "absolute";
 
+export { CursorEvents }
+
 export declare interface CursorOptions {
     enabled?: boolean;
     playerIdentity?: PlayerIdentity;
@@ -170,6 +219,19 @@ export declare interface CursorOptions {
 
 export { CursorPresence }
 
+declare type CursorPresenceTransport = {
+    join(input: {
+        identity: PlayerIdentity_2;
+        page?: string;
+    }): void;
+    update(channel: string, value: unknown): void;
+    clear(channel: string): void;
+    subscribe(listener: (message: PresenceServerMessage) => void): () => void;
+    destroy(): void;
+};
+
+export { CursorPresenceView }
+
 export declare type CursorRoom = "page" | "domain" | "section" | ((context: {
     domain: string;
     pathname: string;
@@ -207,6 +269,8 @@ declare function deleteElementData(tag: string, elementId: string): void;
 
 declare function dispatchPlayEvent(message: EventMessage): void;
 
+export { ElementAwarenessEventHandlerData }
+
 declare class ElementHandler<T = any, U = any, V = any> {
     defaultData: T;
     localData: U;
@@ -273,6 +337,10 @@ declare class ElementHandler<T = any, U = any, V = any> {
     reset(): void;
 }
 
+export { ElementInitializer }
+
+export { getIdForElement }
+
 export declare interface InitOptions<T = unknown> {
     /**
      * The room to connect users to (this should be a string that matches the other users
@@ -323,6 +391,8 @@ export declare interface InitOptions<T = unknown> {
 
 declare function initPlayHTML(options?: InitOptions): Promise<void> | Promise<default_2>;
 
+export { PageDataChannel }
+
 export { PlayerIdentity }
 
 export declare const playhtml: PlayHTMLComponents;
@@ -337,7 +407,7 @@ export declare interface PlayHTMLComponents {
     removePlayElement: typeof removePlayElement;
     deleteElementData: typeof deleteElementData;
     setupPlayElementForTag: typeof setupPlayElementForTag;
-    syncedStore: ReadOnlyStore<(typeof store)["play"]>;
+    syncedStore: ReadOnlyStore<PlayStore["play"]>;
     elementHandlers: Map<string, Map<string, ElementHandler>>;
     eventHandlers: Map<string, Array<RegisteredPlayEvent>>;
     dispatchPlayEvent: typeof dispatchPlayEvent;
@@ -359,6 +429,14 @@ export declare interface PlayHTMLComponents {
     }>;
 }
 
+declare type PlayStore = {
+    readonly play: Partial<Record<string, Record<string, unknown>>>;
+};
+
+export { PresenceRoom }
+
+export { PresenceView }
+
 declare type ReadOnlyStore<T extends object> = DeepReadonlyStore<T>;
 
 /**
@@ -408,12 +486,8 @@ declare function setupPlayElementForTag<T extends TagType | string>(element: HTM
 
 export declare const sharedPermissions: Map<string, "read-only" | "read-write">;
 
-declare let store: MappedTypeDescription<StoreShape>;
-
-declare type StoreShape = {
-    play: Record<string, Record<string, unknown>>;
-};
-
 export { TagType }
 
+export { TagTypeToElement }
+
 export { }