@empty-sekai/sekai-custom-profile-sdk 0.3.0

package/dist/worker-client.js

@@ -0,0 +1,413 @@
+export class RendererWorkerClient {
+    worker;
+    pending = new Map();
+    sequence = 0;
+    closed = false;
+    constructor(worker) {
+        this.worker = worker;
+        worker.onmessage = (event) => this.receive(event.data);
+        worker.onerror = (event) => this.failAll(new RendererWorkerError("WORKER_CRASHED", event.message));
+    }
+    static async create(options = {}) {
+        const workerUrl = options.workerUrl ?? new URL("./worker.js", import.meta.url);
+        const moduleUrl = options.moduleUrl ?? new URL("./allium_renderer_wasm.js", import.meta.url);
+        const wasmUrl = options.wasmUrl ?? new URL("./allium_renderer_wasm.wasm", import.meta.url);
+        const worker = options.workerFactory?.(workerUrl) ?? new Worker(workerUrl, { type: "module", name: "sekai-custom-profile-sdk" });
+        const client = new RendererWorkerClient(worker);
+        const result = await client.request("init", {
+            moduleUrl: moduleUrl.toString(),
+            wasmUrl: wasmUrl.toString(),
+        });
+        if (result.kind !== "init")
+            throw new RendererWorkerError("PROTOCOL_MISMATCH", "Renderer worker returned an invalid init response");
+        return client;
+    }
+    async registerFont(font) {
+        const bytes = font.bytes.slice(0);
+        const result = await this.request("registerFont", { ...font, bytes }, [bytes]);
+        if (result.kind !== "registerFont" || !result.registered)
+            throw new RendererWorkerError("FONT_REGISTRATION_FAILED", "Renderer worker rejected the font");
+    }
+    async contract() {
+        const result = await this.request("contract", {});
+        if (result.kind !== "contract")
+            throw new RendererWorkerError("PROTOCOL_MISMATCH", "Renderer worker returned an invalid contract response");
+        return result.contract;
+    }
+    async mapGlyphs(request) {
+        const result = await this.request("mapGlyphs", request);
+        if (result.kind !== "mapGlyphs")
+            throw new RendererWorkerError("PROTOCOL_MISMATCH", "Renderer worker returned an invalid glyph-map response");
+        return result.batch;
+    }
+    async planGlyphs(request) {
+        const result = await this.request("planGlyphs", request);
+        if (result.kind !== "planGlyphs")
+            throw new RendererWorkerError("PROTOCOL_MISMATCH", "Renderer worker returned an invalid glyph-plan response");
+        return result.plan;
+    }
+    async buildGlyphs(request) {
+        const result = await this.request("buildGlyphs", request);
+        if (result.kind !== "buildGlyphs")
+            throw new RendererWorkerError("PROTOCOL_MISMATCH", "Renderer worker returned an invalid glyph response");
+        return result.batch;
+    }
+    async layoutText(request) {
+        const result = await this.request("layoutText", { request });
+        if (result.kind !== "layoutText")
+            throw new RendererWorkerError("PROTOCOL_MISMATCH", "Renderer worker returned an invalid text-layout response");
+        return result.batch;
+    }
+    async glyphDemand(request) {
+        const result = await this.request("glyphDemand", { request });
+        if (result.kind !== "glyphDemand")
+            throw new RendererWorkerError("PROTOCOL_MISMATCH", "Renderer worker returned an invalid glyph-demand response");
+        return result.batch;
+    }
+    async createAtlas() {
+        const result = await this.request("createAtlas", {});
+        if (result.kind !== "createAtlas")
+            throw new RendererWorkerError("PROTOCOL_MISMATCH", "Renderer worker returned an invalid atlas response");
+        return new RendererAtlas(this, result.atlasId, result.stats);
+    }
+    async createAuthoringDocument(profile) {
+        const result = profile === undefined
+            ? await this.request("createAuthoringBlank", {})
+            : await this.request("importAuthoringProfile", { profile });
+        if (result.kind !== "createAuthoring") {
+            throw new RendererWorkerError("PROTOCOL_MISMATCH", "Renderer worker returned an invalid authoring response");
+        }
+        return new RendererAuthoringDocument(this, result.authoringId, result.document, result.revision);
+    }
+    async restoreAuthoringDocument(checkpoint) {
+        const result = await this.request("restoreAuthoringCheckpoint", { checkpoint });
+        if (result.kind !== "createAuthoring") {
+            throw new RendererWorkerError("PROTOCOL_MISMATCH", "Renderer worker returned an invalid restored authoring response");
+        }
+        return new RendererAuthoringDocument(this, result.authoringId, result.document, result.revision);
+    }
+    async createMasterData(region, revision) {
+        const result = await this.request("createMasterData", { region, revision });
+        if (result.kind !== "createMasterData")
+            throw new RendererWorkerError("PROTOCOL_MISMATCH", "Renderer worker returned an invalid master-data response");
+        const requiredTables = Array.isArray(result.report.required_tables)
+            ? result.report.required_tables.filter((value) => typeof value === "string")
+            : [];
+        return new RendererMasterData(this, result.masterDataId, region, revision, requiredTables);
+    }
+    async stats() {
+        const result = await this.request("stats", {});
+        if (result.kind !== "stats")
+            throw new RendererWorkerError("PROTOCOL_MISMATCH", "Renderer worker returned an invalid stats response");
+        return result.stats;
+    }
+    terminate() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.worker.terminate();
+        this.failAll(new RendererWorkerError("WORKER_TERMINATED", "Renderer worker was terminated"));
+    }
+    async sceneRequest(kind, payload) {
+        return this.request(kind, payload);
+    }
+    request(kind, payload, transfers = []) {
+        if (this.closed)
+            return Promise.reject(new RendererWorkerError("WORKER_TERMINATED", "Renderer worker is closed"));
+        const id = ++this.sequence;
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve, reject });
+            this.worker.postMessage({ id, kind, payload }, transfers);
+        });
+    }
+    receive(response) {
+        const pending = this.pending.get(response.id);
+        if (!pending)
+            return;
+        this.pending.delete(response.id);
+        if (response.ok)
+            pending.resolve(response.result);
+        else
+            pending.reject(new RendererWorkerError(response.error.code, response.error.message));
+    }
+    failAll(error) {
+        for (const pending of this.pending.values())
+            pending.reject(error);
+        this.pending.clear();
+    }
+}
+export class RendererAuthoringDocument {
+    client;
+    id;
+    initialDocument;
+    initialRevision;
+    destroyed = false;
+    constructor(client, id, initialDocument, initialRevision) {
+        this.client = client;
+        this.id = id;
+        this.initialDocument = initialDocument;
+        this.initialRevision = initialRevision;
+    }
+    async apply(command) {
+        this.assertAlive();
+        const result = await this.client.sceneRequest("applyAuthoring", { authoringId: this.id, command });
+        if (result.kind !== "authoringDelta" || result.delta == null) {
+            throw new RendererWorkerError("PROTOCOL_MISMATCH", "Renderer worker returned an invalid authoring delta");
+        }
+        return result.delta;
+    }
+    async select(id) {
+        return this.delta("selectAuthoring", { authoringId: this.id, id });
+    }
+    async elements() {
+        this.assertAlive();
+        const result = await this.client.sceneRequest("elementsAuthoring", { authoringId: this.id });
+        if (result.kind !== "elementsAuthoring") {
+            throw new RendererWorkerError("PROTOCOL_MISMATCH", "Renderer worker returned invalid authoring elements");
+        }
+        return result.elements;
+    }
+    async beginGesture(id) {
+        return this.delta("beginAuthoringGesture", { authoringId: this.id, id });
+    }
+    async previewGesture(command) {
+        return this.delta("previewAuthoringGesture", { authoringId: this.id, command });
+    }
+    async commitGesture() {
+        return this.delta("commitAuthoringGesture", { authoringId: this.id });
+    }
+    async cancelGesture() {
+        return this.delta("cancelAuthoringGesture", { authoringId: this.id });
+    }
+    async appendPage() {
+        return this.delta("appendAuthoringPage", { authoringId: this.id });
+    }
+    async duplicatePage(page) {
+        return this.delta("duplicateAuthoringPage", { authoringId: this.id, page });
+    }
+    async deletePage(page) {
+        return this.delta("deleteAuthoringPage", { authoringId: this.id, page });
+    }
+    async movePage(fromPage, page) {
+        return this.delta("moveAuthoringPage", { authoringId: this.id, fromPage, page });
+    }
+    async undo() {
+        return this.history("undoAuthoring");
+    }
+    async redo() {
+        return this.history("redoAuthoring");
+    }
+    async export() {
+        this.assertAlive();
+        const result = await this.client.sceneRequest("exportAuthoring", { authoringId: this.id });
+        if (result.kind !== "exportAuthoring") {
+            throw new RendererWorkerError("PROTOCOL_MISMATCH", "Renderer worker returned an invalid authoring export");
+        }
+        return result.document;
+    }
+    async checkpoint() {
+        this.assertAlive();
+        const result = await this.client.sceneRequest("checkpointAuthoring", { authoringId: this.id });
+        if (result.kind !== "checkpointAuthoring") {
+            throw new RendererWorkerError("PROTOCOL_MISMATCH", "Renderer worker returned an invalid authoring checkpoint");
+        }
+        return result.checkpoint;
+    }
+    async destroy() {
+        if (this.destroyed)
+            return;
+        const result = await this.client.sceneRequest("destroyAuthoring", { authoringId: this.id });
+        if (result.kind !== "destroyAuthoring" || !result.destroyed) {
+            throw new RendererWorkerError("AUTHORING_DESTROY_FAILED", "Renderer worker did not destroy the authoring session");
+        }
+        this.destroyed = true;
+    }
+    async history(kind) {
+        this.assertAlive();
+        const result = await this.client.sceneRequest(kind, { authoringId: this.id });
+        if (result.kind !== "authoringDelta") {
+            throw new RendererWorkerError("PROTOCOL_MISMATCH", "Renderer worker returned an invalid authoring history response");
+        }
+        return result.delta;
+    }
+    async delta(kind, payload) {
+        this.assertAlive();
+        const result = await this.client.sceneRequest(kind, payload);
+        if (result.kind !== "authoringDelta" || result.delta == null) {
+            throw new RendererWorkerError("PROTOCOL_MISMATCH", "Renderer worker returned an invalid authoring delta");
+        }
+        return result.delta;
+    }
+    assertAlive() {
+        if (this.destroyed)
+            throw new RendererWorkerError("AUTHORING_DESTROYED", "Renderer authoring session is destroyed");
+    }
+}
+export class RendererAtlas {
+    client;
+    id;
+    initialStats;
+    destroyed = false;
+    constructor(client, id, initialStats) {
+        this.client = client;
+        this.id = id;
+        this.initialStats = initialStats;
+    }
+    async resolve(keys, cached, generate) {
+        this.assertAlive();
+        const result = await this.client.sceneRequest("resolveAtlas", { atlasId: this.id, keys, cached, generate });
+        if (result.kind !== "resolveAtlas")
+            throw new RendererWorkerError("PROTOCOL_MISMATCH", "Renderer worker returned an invalid atlas resolution");
+        return result.result;
+    }
+    async pages(revisions) {
+        this.assertAlive();
+        const result = await this.client.sceneRequest("atlasPages", {
+            atlasId: this.id,
+            revisions: [...revisions].map(([page, revision]) => ({ page, revision })),
+        });
+        if (result.kind !== "atlasPages")
+            throw new RendererWorkerError("PROTOCOL_MISMATCH", "Renderer worker returned invalid atlas pages");
+        return result.updates;
+    }
+    async release(lease) {
+        if (this.destroyed)
+            return;
+        const result = await this.client.sceneRequest("releaseAtlas", { atlasId: this.id, lease });
+        if (result.kind !== "releaseAtlas")
+            throw new RendererWorkerError("PROTOCOL_MISMATCH", "Renderer worker returned an invalid atlas lease response");
+    }
+    async destroy() {
+        if (this.destroyed)
+            return;
+        const result = await this.client.sceneRequest("destroyAtlas", { atlasId: this.id });
+        if (result.kind !== "destroyAtlas" || !result.destroyed)
+            throw new RendererWorkerError("ATLAS_DESTROY_FAILED", "Renderer worker did not destroy the atlas session");
+        this.destroyed = true;
+    }
+    assertAlive() {
+        if (this.destroyed)
+            throw new RendererWorkerError("ATLAS_DESTROYED", "Renderer atlas session is destroyed");
+    }
+}
+export class RendererMasterData {
+    client;
+    id;
+    region;
+    revision;
+    requiredTables;
+    destroyed = false;
+    constructor(client, id, region, revision, requiredTables) {
+        this.client = client;
+        this.id = id;
+        this.region = region;
+        this.revision = revision;
+        this.requiredTables = requiredTables;
+    }
+    async putTable(name, table) {
+        return this.report("putMasterDataTable", { masterDataId: this.id, name, table });
+    }
+    async seal() {
+        return this.report("sealMasterData", { masterDataId: this.id });
+    }
+    async prepareProfile(request) {
+        this.assertAlive();
+        const result = await this.client.sceneRequest("prepareProfile", { masterDataId: this.id, request });
+        if (result.kind !== "prepareProfile")
+            throw new RendererWorkerError("PROTOCOL_MISMATCH", "Renderer worker returned an invalid profile preparation");
+        return result.preparation;
+    }
+    /** @internal Profile compilation stays behind BrowserRenderer. */
+    async createProfileScene(request, layoutRequest) {
+        this.assertAlive();
+        const result = await this.client.sceneRequest("createProfileScene", { masterDataId: this.id, request, layoutRequest });
+        if (result.kind !== "createProfileScene")
+            throw new RendererWorkerError("PROTOCOL_MISMATCH", "Renderer worker returned an invalid profile scene");
+        return {
+            scene: new RendererScene(this.client, result.sceneId, result.response),
+            layout: result.layout,
+        };
+    }
+    async destroy() {
+        if (this.destroyed)
+            return;
+        const result = await this.client.sceneRequest("destroyMasterData", { masterDataId: this.id });
+        if (result.kind !== "destroyMasterData" || !result.destroyed)
+            throw new RendererWorkerError("MASTERDATA_DESTROY_FAILED", "Renderer worker did not destroy the master-data session");
+        this.destroyed = true;
+    }
+    async report(kind, payload) {
+        this.assertAlive();
+        const result = await this.client.sceneRequest(kind, payload);
+        if (result.kind !== "masterDataReport")
+            throw new RendererWorkerError("PROTOCOL_MISMATCH", "Renderer worker returned an invalid master-data report");
+        return result.report;
+    }
+    assertAlive() {
+        if (this.destroyed)
+            throw new RendererWorkerError("MASTERDATA_DESTROYED", "Renderer master-data session is destroyed");
+    }
+}
+export class RendererScene {
+    client;
+    id;
+    initial;
+    destroyed = false;
+    constructor(client, id, initial) {
+        this.client = client;
+        this.id = id;
+        this.initial = initial;
+    }
+    async advance(tick) {
+        return this.delta("advance", { sceneId: this.id, tick });
+    }
+    async setLayerVisible(layerId, visible) {
+        return this.delta("setLayerMask", { sceneId: this.id, layerId, visible });
+    }
+    async setLayerMasks(expectedLayerTableRevision, overrides) {
+        return this.delta("setLayerMasks", { sceneId: this.id, expectedLayerTableRevision, overrides });
+    }
+    async setTab(controlId, value) {
+        return this.delta("setTab", { sceneId: this.id, controlId, value });
+    }
+    async setScrollOffset(controlId, offset) {
+        return this.delta("scroll", { sceneId: this.id, controlId, offset });
+    }
+    async scrollBy(controlId, delta) {
+        return this.delta("scroll", { sceneId: this.id, controlId, delta });
+    }
+    async dump() {
+        this.assertAlive();
+        const result = await this.client.sceneRequest("dumpScene", { sceneId: this.id });
+        if (result.kind !== "dumpScene")
+            throw new RendererWorkerError("PROTOCOL_MISMATCH", "Renderer worker returned an invalid dump response");
+        return result.dump;
+    }
+    async destroy() {
+        if (this.destroyed)
+            return;
+        const result = await this.client.sceneRequest("destroyScene", { sceneId: this.id });
+        if (result.kind !== "destroyScene" || !result.destroyed)
+            throw new RendererWorkerError("SCENE_DESTROY_FAILED", "Renderer worker did not destroy the scene");
+        this.destroyed = true;
+    }
+    async delta(kind, payload) {
+        this.assertAlive();
+        const result = await this.client.sceneRequest(kind, payload);
+        if (result.kind !== "delta")
+            throw new RendererWorkerError("PROTOCOL_MISMATCH", "Renderer worker returned an invalid scene delta");
+        return result.delta;
+    }
+    assertAlive() {
+        if (this.destroyed)
+            throw new RendererWorkerError("SCENE_DESTROYED", "Renderer scene is destroyed");
+    }
+}
+export class RendererWorkerError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "RendererWorkerError";
+    }
+}

package/dist/worker.d.ts

@@ -0,0 +1 @@
+export {};