@honua/app-platform 0.0.20-alpha.0

package/collaboration/client.d.ts

@@ -0,0 +1,40 @@
+import type { SavedMapCollaborationEnvelope, SavedMapCollaborationJoinRequest, SavedMapCollaborationReconnectOptions, SavedMapCollaborationSessionRef, SavedMapCollaborationSnapshot, SavedMapCollaborationSnapshotListener, SavedMapCollaborationTransport, SavedMapCursor, SavedMapFeatureLock, SavedMapFeatureLockReleaseRequest, SavedMapFeatureLockRequest, SavedMapOperationReplayRequest, SavedMapOperationReplayResult, SavedMapOperationSubmitRequest, SavedMapSelection } from "./types.js";
+export interface HonuaSavedMapCollaborationClientOptions<TPayload = unknown> {
+    readonly transport: SavedMapCollaborationTransport<TPayload>;
+}
+export declare function createHonuaSavedMapCollaboration<TPayload = unknown>(options: HonuaSavedMapCollaborationClientOptions<TPayload>): HonuaSavedMapCollaborationClient<TPayload>;
+export declare class HonuaSavedMapCollaborationClient<TPayload = unknown> {
+    #private;
+    constructor(options: HonuaSavedMapCollaborationClientOptions<TPayload>);
+    joinSavedMap(request: SavedMapCollaborationJoinRequest): Promise<HonuaSavedMapCollaborationSession<TPayload>>;
+}
+export declare class HonuaSavedMapCollaborationSession<TPayload = unknown> {
+    #private;
+    constructor(transport: SavedMapCollaborationTransport<TPayload>, session: SavedMapCollaborationSessionRef, snapshot: SavedMapCollaborationSnapshot<TPayload>);
+    get mapId(): string;
+    get sessionId(): string;
+    get participantId(): string;
+    get snapshot(): SavedMapCollaborationSnapshot<TPayload>;
+    subscribe(listener: SavedMapCollaborationSnapshotListener<TPayload>, options?: {
+        readonly fireImmediately?: boolean;
+    }): () => void;
+    connect(status?: "connecting" | "reconnecting"): void;
+    disconnect(): void;
+    reconnect(options?: SavedMapCollaborationReconnectOptions): Promise<SavedMapOperationReplayResult<TPayload> | undefined>;
+    leave(): Promise<void>;
+    publishCursor(cursor: SavedMapCursor): Promise<SavedMapCollaborationEnvelope<TPayload>>;
+    publishSelection(selection: SavedMapSelection): Promise<SavedMapCollaborationEnvelope<TPayload>>;
+    follow(participantId: string): Promise<SavedMapCollaborationEnvelope<TPayload>>;
+    unfollow(): Promise<SavedMapCollaborationEnvelope<TPayload>>;
+    claimFeatureLock(request: SavedMapFeatureLockRequest): Promise<SavedMapFeatureLock>;
+    releaseFeatureLock(request: SavedMapFeatureLockReleaseRequest): Promise<void>;
+    renewFeatureLock(request: SavedMapFeatureLockRequest): Promise<SavedMapFeatureLock>;
+    submitOperation(request: SavedMapOperationSubmitRequest<TPayload>): Promise<SavedMapOperationReplayResult<TPayload>["operations"][number]>;
+    replayOperations(request?: SavedMapOperationReplayRequest): Promise<SavedMapOperationReplayResult<TPayload>>;
+    private apply;
+    private emit;
+    private closeSubscription;
+    private applyError;
+}
+export declare function reduceSavedMapCollaborationSnapshot<TPayload>(snapshot: SavedMapCollaborationSnapshot<TPayload>, envelope: SavedMapCollaborationEnvelope<TPayload>): SavedMapCollaborationSnapshot<TPayload>;
+//# sourceMappingURL=client.d.ts.map

package/collaboration/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../src/collaboration/client.ts"],"names":[],"mappings":"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"}

package/collaboration/client.js

@@ -0,0 +1,299 @@
+import { HonuaCollaborationError } from "./errors.js";
+export function createHonuaSavedMapCollaboration(options) {
+    return new HonuaSavedMapCollaborationClient(options);
+}
+export class HonuaSavedMapCollaborationClient {
+    #transport;
+    constructor(options) {
+        this.#transport = options.transport;
+    }
+    async joinSavedMap(request) {
+        const joined = await this.#transport.join(request);
+        const session = new HonuaSavedMapCollaborationSession(this.#transport, joined, joined.snapshot);
+        session.connect();
+        return session;
+    }
+}
+export class HonuaSavedMapCollaborationSession {
+    #transport;
+    #session;
+    #listeners = new Set();
+    #snapshot;
+    #handle;
+    #closed = false;
+    #subscriptionGeneration = 0;
+    constructor(transport, session, snapshot) {
+        this.#transport = transport;
+        this.#session = session;
+        this.#snapshot = snapshot;
+    }
+    get mapId() {
+        return this.#session.mapId;
+    }
+    get sessionId() {
+        return this.#session.sessionId;
+    }
+    get participantId() {
+        return this.#session.participantId;
+    }
+    get snapshot() {
+        return this.#snapshot;
+    }
+    subscribe(listener, options = {}) {
+        this.#listeners.add(listener);
+        if (options.fireImmediately)
+            listener(this.#snapshot);
+        return () => {
+            this.#listeners.delete(listener);
+        };
+    }
+    connect(status = "connecting") {
+        if (this.#closed || this.#handle)
+            return;
+        const generation = ++this.#subscriptionGeneration;
+        this.#snapshot = { ...this.#snapshot, status, error: undefined };
+        this.emit();
+        this.#handle = this.#transport.subscribe(this.#session, {
+            next: (envelope) => {
+                if (generation === this.#subscriptionGeneration)
+                    this.apply(envelope);
+            },
+            error: (error) => {
+                if (generation === this.#subscriptionGeneration)
+                    this.applyError(error);
+            },
+            complete: () => {
+                if (generation !== this.#subscriptionGeneration)
+                    return;
+                this.#snapshot = { ...this.#snapshot, status: "closed" };
+                this.#handle = undefined;
+                this.emit();
+            },
+        });
+    }
+    disconnect() {
+        if (this.#closed)
+            return;
+        this.closeSubscription();
+        this.#snapshot = { ...this.#snapshot, status: "stale" };
+        this.emit();
+    }
+    async reconnect(options = {}) {
+        if (this.#closed) {
+            throw new HonuaCollaborationError("transport-failure", "Cannot reconnect a closed collaboration session.");
+        }
+        this.closeSubscription();
+        this.#snapshot = { ...this.#snapshot, status: "reconnecting", error: undefined };
+        this.emit();
+        let replay;
+        if (options.replayOperations !== false) {
+            try {
+                replay = await this.#transport.replayOperations(this.#session, replayRequestForSnapshot(this.#snapshot, options));
+                this.#snapshot = mergeReplayedOperations(this.#snapshot, replay);
+                this.emit();
+            }
+            catch (error) {
+                this.applyError(error);
+                throw error;
+            }
+        }
+        this.connect("reconnecting");
+        return replay;
+    }
+    async leave() {
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        this.closeSubscription();
+        await this.#transport.leave(this.#session);
+        this.#snapshot = { ...this.#snapshot, status: "closed" };
+        this.emit();
+        this.#listeners.clear();
+    }
+    publishCursor(cursor) {
+        return this.#transport.publishCursor(this.#session, cursor);
+    }
+    publishSelection(selection) {
+        return this.#transport.publishSelection(this.#session, selection);
+    }
+    follow(participantId) {
+        return this.#transport.publishFollow(this.#session, { following: true, targetParticipantId: participantId });
+    }
+    unfollow() {
+        return this.#transport.publishFollow(this.#session, { following: false });
+    }
+    claimFeatureLock(request) {
+        return this.#transport.claimFeatureLock(this.#session, request);
+    }
+    releaseFeatureLock(request) {
+        return this.#transport.releaseFeatureLock(this.#session, request);
+    }
+    renewFeatureLock(request) {
+        return this.#transport.renewFeatureLock(this.#session, request);
+    }
+    submitOperation(request) {
+        return this.#transport.submitOperation(this.#session, request);
+    }
+    replayOperations(request = {}) {
+        return this.#transport.replayOperations(this.#session, request);
+    }
+    apply(envelope) {
+        if (envelope.mapId !== this.mapId)
+            return;
+        const next = reduceSavedMapCollaborationSnapshot(this.#snapshot, envelope);
+        if (Object.is(next, this.#snapshot))
+            return;
+        this.#snapshot = next;
+        this.emit(envelope);
+    }
+    emit(envelope) {
+        for (const listener of [...this.#listeners])
+            listener(this.#snapshot, envelope);
+    }
+    closeSubscription() {
+        if (!this.#handle)
+            return;
+        const handle = this.#handle;
+        this.#handle = undefined;
+        this.#subscriptionGeneration++;
+        handle.close();
+    }
+    applyError(error) {
+        const collaborationError = error instanceof HonuaCollaborationError
+            ? error
+            : new HonuaCollaborationError("transport-failure", "Collaboration transport failed.", { cause: error });
+        this.#snapshot = {
+            ...this.#snapshot,
+            status: "error",
+            error: {
+                type: "error",
+                code: collaborationError.code,
+                message: collaborationError.message,
+                retryAfterMs: collaborationError.retryAfterMs,
+                resyncRequired: collaborationError.resyncRequired,
+                details: collaborationError.details,
+            },
+        };
+        this.emit();
+    }
+}
+export function reduceSavedMapCollaborationSnapshot(snapshot, envelope) {
+    if (envelope.event.type === "snapshot") {
+        return { ...envelope.event.snapshot, status: "live", cursor: envelope.cursor, sequence: envelope.sequence };
+    }
+    if (envelope.sequence <= snapshot.sequence)
+        return snapshot;
+    const base = {
+        ...snapshot,
+        sequence: envelope.sequence,
+        cursor: envelope.cursor,
+        status: "live",
+        error: undefined,
+    };
+    switch (envelope.event.type) {
+        case "participant-joined":
+            return {
+                ...base,
+                participants: upsertById(base.participants, envelope.event.participant),
+            };
+        case "participant-left": {
+            const event = envelope.event;
+            return {
+                ...base,
+                participants: base.participants.filter((participant) => participant.id !== event.participantId),
+                cursors: omitKey(base.cursors, event.participantId),
+                selections: omitKey(base.selections, event.participantId),
+                followTargets: omitKey(base.followTargets, event.participantId),
+                featureLocks: base.featureLocks.filter((lock) => lock.ownerId !== event.participantId),
+            };
+        }
+        case "cursor":
+            return {
+                ...base,
+                cursors: { ...base.cursors, [envelope.event.participantId]: envelope.event.cursor },
+            };
+        case "selection":
+            return {
+                ...base,
+                selections: { ...base.selections, [envelope.event.participantId]: envelope.event.selection },
+            };
+        case "follow":
+            return {
+                ...base,
+                followTargets: { ...base.followTargets, [envelope.event.participantId]: envelope.event.follow },
+            };
+        case "feature-lock-claimed":
+        case "feature-lock-renewed":
+            return {
+                ...base,
+                featureLocks: upsertLock(base.featureLocks, envelope.event.lock),
+            };
+        case "feature-lock-released": {
+            const event = envelope.event;
+            return {
+                ...base,
+                featureLocks: base.featureLocks.filter((lock) => !sameFeatureLockTarget(lock, {
+                    featureId: event.featureId,
+                    sourceId: event.sourceId,
+                    layerId: event.layerId,
+                })),
+            };
+        }
+        case "operation-appended":
+            return {
+                ...base,
+                operations: [...base.operations, envelope.event.operation],
+            };
+        case "status":
+            return { ...base, status: envelope.event.status };
+        case "error":
+            return {
+                ...base,
+                status: "error",
+                error: envelope.event,
+            };
+    }
+}
+function upsertById(items, item) {
+    const existing = items.findIndex((candidate) => candidate.id === item.id);
+    if (existing === -1)
+        return [...items, item];
+    return items.map((candidate, index) => (index === existing ? item : candidate));
+}
+function upsertLock(locks, lock) {
+    const existing = locks.findIndex((candidate) => sameFeatureLockTarget(candidate, lock));
+    if (existing === -1)
+        return [...locks, lock];
+    return locks.map((candidate, index) => (index === existing ? lock : candidate));
+}
+function sameFeatureLockTarget(left, right) {
+    return left.featureId === right.featureId && left.sourceId === right.sourceId && left.layerId === right.layerId;
+}
+function omitKey(record, key) {
+    const { [key]: _removed, ...rest } = record;
+    return rest;
+}
+function replayRequestForSnapshot(snapshot, options) {
+    const { replayOperations: _replayOperations, ...request } = options;
+    if (request.afterCursor !== undefined || request.afterSequence !== undefined)
+        return request;
+    if (snapshot.cursor !== undefined)
+        return { ...request, afterCursor: snapshot.cursor };
+    return { ...request, afterSequence: snapshot.sequence };
+}
+function mergeReplayedOperations(snapshot, replay) {
+    const operationIds = new Set(snapshot.operations.map((operation) => operation.id));
+    const operations = [...snapshot.operations];
+    for (const operation of replay.operations) {
+        if (operationIds.has(operation.id))
+            continue;
+        operationIds.add(operation.id);
+        operations.push(operation);
+    }
+    return {
+        ...snapshot,
+        operations,
+        sequence: Math.max(snapshot.sequence, replay.sequence),
+        cursor: replay.cursor ?? snapshot.cursor,
+    };
+}

package/collaboration/errors.d.ts

@@ -0,0 +1,15 @@
+import type { SavedMapCollaborationErrorCode } from "./types.js";
+export declare class HonuaCollaborationError extends Error {
+    readonly code: SavedMapCollaborationErrorCode;
+    readonly details: unknown;
+    readonly retryAfterMs: number | undefined;
+    readonly resyncRequired: boolean;
+    constructor(code: SavedMapCollaborationErrorCode, message: string, options?: {
+        readonly details?: unknown;
+        readonly retryAfterMs?: number;
+        readonly resyncRequired?: boolean;
+        readonly cause?: unknown;
+    });
+}
+export declare function isHonuaCollaborationError(error: unknown): error is HonuaCollaborationError;
+//# sourceMappingURL=errors.d.ts.map

package/collaboration/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/collaboration/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,YAAY,CAAC;AAEjE,qBAAa,uBAAwB,SAAQ,KAAK;IAChD,SAAgB,IAAI,EAAE,8BAA8B,CAAC;IACrD,SAAgB,OAAO,EAAE,OAAO,CAAC;IACjC,SAAgB,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;IACjD,SAAgB,cAAc,EAAE,OAAO,CAAC;gBAGtC,IAAI,EAAE,8BAA8B,EACpC,OAAO,EAAE,MAAM,EACf,OAAO,GAAE;QACP,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;QAC3B,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;QAC/B,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAC;QAClC,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;KACrB;CAST;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,uBAAuB,CAE1F"}

package/collaboration/errors.js

@@ -0,0 +1,17 @@
+export class HonuaCollaborationError extends Error {
+    code;
+    details;
+    retryAfterMs;
+    resyncRequired;
+    constructor(code, message, options = {}) {
+        super(message, options.cause === undefined ? undefined : { cause: options.cause });
+        this.name = "HonuaCollaborationError";
+        this.code = code;
+        this.details = options.details;
+        this.retryAfterMs = options.retryAfterMs;
+        this.resyncRequired = options.resyncRequired ?? (code === "resync-required" || code === "stale-cursor");
+    }
+}
+export function isHonuaCollaborationError(error) {
+    return error instanceof HonuaCollaborationError;
+}

package/collaboration/fixture.d.ts

@@ -0,0 +1,41 @@
+import type { SavedMapCollaborationCapabilities, SavedMapCollaborationEnvelope, SavedMapCollaborationJoinRequest, SavedMapCollaborationJoinResult, SavedMapCollaborationObserver, SavedMapCollaborationSessionRef, SavedMapCollaborationSubscriptionHandle, SavedMapCollaborationTransport, SavedMapCommittedOperation, SavedMapCursor, SavedMapFeatureLock, SavedMapFeatureLockReleaseRequest, SavedMapFeatureLockRequest, SavedMapFollowTarget, SavedMapOperationReplayRequest, SavedMapOperationReplayResult, SavedMapOperationSubmitRequest, SavedMapSelection } from "./types.js";
+export interface FixtureSavedMapCollaborationTransportOptions {
+    readonly now?: () => Date;
+    readonly capabilities?: Partial<SavedMapCollaborationCapabilities>;
+    readonly deniedMapIds?: ReadonlyArray<string>;
+    readonly unsupportedMapIds?: ReadonlyArray<string>;
+}
+export declare function createFixtureSavedMapCollaborationTransport<TPayload = unknown>(options?: FixtureSavedMapCollaborationTransportOptions): FixtureSavedMapCollaborationTransport<TPayload>;
+export declare class FixtureSavedMapCollaborationTransport<TPayload = unknown> implements SavedMapCollaborationTransport<TPayload> {
+    #private;
+    readonly capabilities: {
+        kind: "mock";
+        resumable: boolean;
+        ordered: boolean;
+        replay: boolean;
+    };
+    constructor(options?: FixtureSavedMapCollaborationTransportOptions);
+    join(request: SavedMapCollaborationJoinRequest): Promise<SavedMapCollaborationJoinResult<TPayload>>;
+    leave(session: SavedMapCollaborationSessionRef): Promise<void>;
+    subscribe(session: SavedMapCollaborationSessionRef, observer: SavedMapCollaborationObserver<TPayload>): SavedMapCollaborationSubscriptionHandle;
+    publishCursor(session: SavedMapCollaborationSessionRef, cursor: SavedMapCursor): Promise<SavedMapCollaborationEnvelope<TPayload>>;
+    publishSelection(session: SavedMapCollaborationSessionRef, selection: SavedMapSelection): Promise<SavedMapCollaborationEnvelope<TPayload>>;
+    publishFollow(session: SavedMapCollaborationSessionRef, follow: SavedMapFollowTarget): Promise<SavedMapCollaborationEnvelope<TPayload>>;
+    claimFeatureLock(session: SavedMapCollaborationSessionRef, request: SavedMapFeatureLockRequest): Promise<SavedMapFeatureLock>;
+    releaseFeatureLock(session: SavedMapCollaborationSessionRef, request: SavedMapFeatureLockReleaseRequest): Promise<void>;
+    renewFeatureLock(session: SavedMapCollaborationSessionRef, request: SavedMapFeatureLockRequest): Promise<SavedMapFeatureLock>;
+    submitOperation(session: SavedMapCollaborationSessionRef, request: SavedMapOperationSubmitRequest<TPayload>): Promise<SavedMapCommittedOperation<TPayload>>;
+    replayOperations(session: SavedMapCollaborationSessionRef, request?: SavedMapOperationReplayRequest): Promise<SavedMapOperationReplayResult<TPayload>>;
+    markResyncRequired(mapId: string, message?: string): void;
+    private rejectUnavailableMap;
+    private mapState;
+    private appendAndFanOut;
+    private snapshot;
+    private envelope;
+    private snapshotEnvelope;
+    private errorEnvelope;
+    private lockFor;
+    private operationFor;
+    private nowIso;
+}
+//# sourceMappingURL=fixture.d.ts.map

package/collaboration/fixture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixture.d.ts","sourceRoot":"","sources":["../../../src/collaboration/fixture.ts"],"names":[],"mappings":"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"}