@pluv/client 5.0.1 → 5.0.2

package/eslint.config.mjs

@@ -1,4 +0,0 @@
-import { config } from "eslint-config-pluv/base";
-
-/** @type {import("eslint").Linter.Config} */
-export default config;

package/src/AbstractStorageStore.ts

@@ -1,19 +0,0 @@
-export abstract class AbstractStorageStore {
-    public room: string;
-
-    constructor(room: string) {
-        this.room = room;
-    }
-
-    public abstract addUpdate(update: string): Promise<void>;
-
-    public abstract destroy(): Promise<void>;
-
-    public abstract flatten(encodedState: string): Promise<void>;
-
-    public abstract getShouldFlatten(): Promise<boolean>;
-
-    public abstract getUpdates(start?: number): Promise<readonly string[]>;
-
-    public abstract initialize(): Promise<void>;
-}

package/src/CrdtManager.ts

@@ -1,119 +0,0 @@
-import type { AbstractCrdtDocFactory, InferDocLike, InferStorage } from "@pluv/crdt";
-import { noop } from "@pluv/crdt";
-
-export type CrdtManagerOptions<TCrdt extends AbstractCrdtDocFactory<any, any>> = {
-    initialStorage?: TCrdt;
-};
-
-interface CrdtManagerInitializeParams {
-    origin?: any;
-    update: string | readonly string[];
-}
-
-interface ApplyUpdateParams {
-    origin?: any;
-    update: string | readonly string[];
-}
-
-export class CrdtManager<TCrdt extends AbstractCrdtDocFactory<any, any>> {
-    public doc: InferDocLike<TCrdt>;
-    public initialized: boolean = false;
-
-    private readonly _docFactory: TCrdt;
-
-    constructor(options: CrdtManagerOptions<TCrdt>) {
-        const { initialStorage = noop.doc({}) as any } = options;
-
-        this._docFactory = initialStorage;
-        this.doc = this._docFactory.getEmpty() as InferDocLike<TCrdt>;
-    }
-
-    /**
-     * !HACK
-     * @description If this is called before the doc is initialized. Omit the
-     * update. This unfortunately means updates can be dropped entirely
-     * @date June 13, 2023
-     */
-    public applyUpdate(params: ApplyUpdateParams): this {
-        const { origin, update } = params;
-
-        if (!this.initialized) return this;
-
-        const updates: readonly string[] = typeof update === "string" ? [update] : update;
-
-        this._applyDocUpdates(this.doc, updates, origin);
-
-        return this;
-    }
-
-    public destroy(): void {
-        this.initialized = false;
-        this.doc.destroy();
-        this.doc = this._docFactory.getEmpty() as InferDocLike<TCrdt>;
-    }
-
-    public get<TKey extends keyof InferStorage<TCrdt>>(key: TKey): InferStorage<TCrdt>[TKey] {
-        return this.doc.get(key);
-    }
-
-    public getInitialState(): string {
-        return this._docFactory.getInitialized().getEncodedState();
-    }
-
-    public initialize(params: CrdtManagerInitializeParams): this {
-        const { origin, update } = params;
-
-        /**
-         * !HACK
-         * @description If the doc was already initialized, we don't want to re-initialize
-         * the doc and overwrite what's already there. Skip the initialization and log a
-         * warning.
-         * @date May 7, 2025
-         */
-        if (this.initialized) {
-            console.warn("Attempted to initialize storage multiple times");
-            return this;
-        }
-
-        /**
-         * !HACK
-         * @description If the doc is already populated, somehow we're attempting to overwrite
-         * a doc that was presumably initialized but not identified as initialized. Skip the
-         * initialization and log a warning.
-         * @date May 7, 2025
-         */
-        if (!this.doc.isEmpty()) {
-            console.warn("Attempted to initialize over a non-empty storage");
-            return this;
-        }
-
-        const updates = typeof update === "string" ? [update] : update;
-
-        if (!updates.length) return this;
-
-        const initialized = this._docFactory.getInitialized();
-        const reference = initialized.get();
-
-        this.doc = this._applyDocUpdates(this.doc, updates, origin).rebuildStorage(reference);
-        this.initialized = true;
-        initialized.destroy();
-
-        return this;
-    }
-
-    public resolveEncodedState(updates: string | string[] | readonly string[]): string | null {
-        return this._docFactory.resolveEncodedState(updates);
-    }
-
-    private _applyDocUpdates(
-        doc: InferDocLike<TCrdt>,
-        updates: readonly string[],
-        origin?: string,
-    ): InferDocLike<TCrdt> {
-        doc.transact(() => {
-            doc.batchApplyEncodedState({ origin, updates });
-        }, origin);
-
-        return doc;
-    }
-}

package/src/CrdtNotifier.ts

@@ -1,46 +0,0 @@
-import type { CrdtType, InferCrdtJson } from "@pluv/crdt";
-import type { StorageSubscriptionCallback } from "@pluv/types";
-import type { Subject } from "wonka";
-import { makeSubject, subscribe } from "wonka";
-
-export class CrdtNotifier<TStorage extends Record<string, CrdtType<any, any>>> {
-    public rootSubject = makeSubject<{
-        [P in keyof TStorage]: InferCrdtJson<TStorage[P]>;
-    }>();
-
-    public subjects = new Map<
-        keyof TStorage,
-        Subject<InferCrdtJson<TStorage[keyof TStorage]>> | null
-    >();
-
-    public subject<TKey extends keyof TStorage>(key: TKey): Subject<InferCrdtJson<TStorage[TKey]>> {
-        const subject = this.subjects.get(key);
-
-        if (subject) {
-            return subject as Subject<InferCrdtJson<TStorage[TKey]>>;
-        }
-
-        const newSubject = makeSubject<InferCrdtJson<TStorage[TKey]>>();
-
-        this.subjects.set(key, newSubject);
-
-        return newSubject as Subject<InferCrdtJson<TStorage[TKey]>>;
-    }
-
-    public subcribeRoot(
-        callback: (value: {
-            [P in keyof TStorage]: InferCrdtJson<TStorage[P]>;
-        }) => void,
-    ): () => void {
-        return subscribe(callback)(this.rootSubject.source).unsubscribe;
-    }
-
-    public subscribe<TKey extends keyof TStorage>(
-        key: TKey,
-        callback: StorageSubscriptionCallback<TStorage, TKey>,
-    ): () => void {
-        const subject = this.subject(key);
-
-        return subscribe(callback)(subject.source).unsubscribe;
-    }
-}

package/src/EventNotifier.ts

@@ -1,39 +0,0 @@
-import type {
-    EventNotifierSubscriptionCallback,
-    Id,
-    InferIOOutput,
-    IOEventMessage,
-    IOLike,
-} from "@pluv/types";
-import type { Subject } from "wonka";
-import { makeSubject, subscribe } from "wonka";
-
-export class EventNotifier<TIO extends IOLike> {
-    public subjects = new Map<
-        keyof InferIOOutput<TIO>,
-        Subject<Id<IOEventMessage<TIO, keyof InferIOOutput<TIO>>>>
-    >();
-
-    public subject<TEvent extends keyof InferIOOutput<TIO>>(
-        name: TEvent,
-    ): Subject<Id<IOEventMessage<TIO, TEvent>>> {
-        const subject = this.subjects.get(name);
-
-        if (subject) return subject;
-
-        const newSubject = makeSubject<Id<IOEventMessage<TIO, TEvent>>>();
-
-        this.subjects.set(name, newSubject);
-
-        return newSubject;
-    }
-
-    public subscribe<TEvent extends keyof InferIOOutput<TIO>>(
-        name: TEvent,
-        callback: EventNotifierSubscriptionCallback<TIO, TEvent>,
-    ): () => void {
-        const subject = this.subject(name);
-
-        return subscribe(callback)(subject.source).unsubscribe;
-    }
-}

package/src/ListenerManager.ts

@@ -1,21 +0,0 @@
-import { makeSubject, subscribe, TypeOfSource } from "wonka";
-
-export class ListenerManager {
-    public subjects = {
-        close: makeSubject<CloseEvent>(),
-        error: makeSubject<Event>(),
-        message: makeSubject<MessageEvent<any>>(),
-        open: makeSubject<Event>(),
-    };
-
-    public subscribe<TKind extends keyof typeof this.subjects>(
-        kind: TKind,
-        callback: (event: TypeOfSource<(typeof this.subjects)[TKind]["source"]>) => void,
-    ): () => void {
-        const source = this.subjects[kind]?.source;
-
-        if (!source) return () => undefined;
-
-        return subscribe(callback)(source as any).unsubscribe;
-    }
-}