@timbro/invoices 0.7.0-next.30

package/dist/document.js

@@ -0,0 +1,204 @@
+// biome-ignore-all lint/correctness/useQwikValidLexicalScope: this module is a plain SDK worker adapter, not a Qwik component.
+import { DOCUMENT_EVALUATION_PROTOCOL as DOCUMENT_EVALUATION_PROTOCOL_VALUE, decodeDocumentWorkerEvent, decodeDocumentWorkerResponse, } from "./document-worker-protocol.js";
+import { zSourceDocumentEvaluationRequest } from "./generated/index.js";
+export const DOCUMENT_EVALUATION_PROTOCOL = DOCUMENT_EVALUATION_PROTOCOL_VALUE;
+export class FiscalDocumentEvaluatorError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.name = "FiscalDocumentEvaluatorError";
+        this.code = code;
+    }
+}
+let defaultEvaluator;
+/** Evaluates a Source sales draft through the lazy browser-safe Rust/Wasm document runtime. */
+export function evaluateFiscalDocument(input) {
+    defaultEvaluator ??= createDocumentEvaluator();
+    return defaultEvaluator.evaluate(input);
+}
+/** Releases the lazily created default worker, if one has been created. */
+export function disposeFiscalDocumentEvaluator() {
+    defaultEvaluator?.dispose();
+    defaultEvaluator = undefined;
+}
+/** Creates an evaluator while keeping worker and artifact details out of the common call. */
+export function createDocumentEvaluator(options = {}) {
+    const workerRuntime = options.runtime === undefined ? createWorkerRuntime(options) : undefined;
+    const runtime = options.runtime ??
+        ((requestJson) => {
+            if (workerRuntime === undefined) {
+                throw new FiscalDocumentEvaluatorError("no fiscal document runtime is available", "runtime_unavailable");
+            }
+            return workerRuntime.evaluate(requestJson);
+        });
+    return {
+        async evaluate(input) {
+            const request = zSourceDocumentEvaluationRequest.parse({
+                protocol: DOCUMENT_EVALUATION_PROTOCOL,
+                request_id: crypto.randomUUID(),
+                document: input.document,
+            });
+            const serialized = await runtime(JSON.stringify(request));
+            if (typeof serialized !== "string") {
+                throw new FiscalDocumentEvaluatorError("the fiscal document runtime returned a non-string response", "protocol_mismatch");
+            }
+            let candidate;
+            try {
+                candidate = JSON.parse(serialized);
+            }
+            catch (cause) {
+                const error = new FiscalDocumentEvaluatorError("the fiscal document runtime returned invalid JSON", "protocol_mismatch");
+                error.cause = cause;
+                throw error;
+            }
+            const decoded = decodeDocumentWorkerResponse(candidate, request.request_id);
+            if (decoded.outcome === "protocol_mismatch") {
+                throw new FiscalDocumentEvaluatorError(decoded.detail, "protocol_mismatch");
+            }
+            return decoded.response;
+        },
+        dispose: () => workerRuntime?.dispose(),
+    };
+}
+function createWorkerRuntime(options) {
+    const worker = options.worker ?? createDefaultWorker();
+    const timeoutMs = options.timeoutMs ?? 15_000;
+    const glueModuleUrl = options.glueModuleUrl ?? new URL("./timbro_fiscal_engine.js", import.meta.url).href;
+    const wasmModuleUrl = options.wasmModuleUrl ?? new URL("./timbro_fiscal_engine_bg.wasm", import.meta.url).href;
+    let initialized = false;
+    let sequence = 0;
+    const pending = new Map();
+    let disposed = false;
+    let terminalError;
+    const rejectAll = (error) => {
+        for (const [requestId, item] of pending) {
+            clearTimeout(item.timer);
+            pending.delete(requestId);
+            item.reject(error);
+        }
+    };
+    const rejectOne = (requestId, error) => {
+        const item = pending.get(requestId);
+        if (item === undefined) {
+            return;
+        }
+        clearTimeout(item.timer);
+        pending.delete(requestId);
+        item.reject(error);
+    };
+    const complete = (requestId, response) => {
+        const item = pending.get(requestId);
+        if (item === undefined) {
+            return;
+        }
+        clearTimeout(item.timer);
+        pending.delete(requestId);
+        item.resolve(JSON.stringify(response));
+    };
+    const routeFailure = (requestId, detail, code) => {
+        const error = new FiscalDocumentEvaluatorError(detail, code);
+        if (requestId !== null && pending.has(requestId)) {
+            rejectOne(requestId, error);
+        }
+        else {
+            rejectAll(error);
+        }
+    };
+    const onMessage = (event) => {
+        if (!("data" in event)) {
+            return;
+        }
+        const candidate = event.data;
+        const requestId = workerRequestId(candidate);
+        const expectedEvaluatorRequestId = pending.get(requestId ?? "")?.evaluatorRequestId ?? null;
+        const decoded = decodeDocumentWorkerEvent(candidate, requestId, expectedEvaluatorRequestId);
+        if (decoded.outcome !== "evaluated") {
+            routeFailure(requestId, decoded.detail, decoded.outcome === "failed" ? "worker_failure" : "protocol_mismatch");
+            return;
+        }
+        if (requestId !== null) {
+            complete(requestId, decoded.response);
+        }
+    };
+    const onWorkerError = () => {
+        terminalError = new FiscalDocumentEvaluatorError("the fiscal document worker failed", "worker_failure");
+        rejectAll(terminalError);
+    };
+    const onMessageError = () => rejectAll(new FiscalDocumentEvaluatorError("the fiscal document worker returned an unreadable message", "protocol_mismatch"));
+    const postEvaluation = (requestId, requestJson, rejectOneRequest) => {
+        try {
+            if (!initialized) {
+                worker.postMessage({
+                    type: "initialize",
+                    glue_module_url: glueModuleUrl,
+                    wasm_module_url: wasmModuleUrl,
+                });
+                initialized = true;
+            }
+            worker.postMessage({ type: "evaluate", request_id: requestId, request: requestJson });
+        }
+        catch (cause) {
+            rejectOneRequest(requestId, new FiscalDocumentEvaluatorError(cause instanceof Error
+                ? cause.message
+                : "the fiscal document worker could not be reached", "worker_failure"));
+        }
+    };
+    worker.addEventListener("message", onMessage);
+    worker.addEventListener("error", onWorkerError);
+    worker.addEventListener("messageerror", onMessageError);
+    const evaluate = (requestJson) => {
+        if (disposed || terminalError !== undefined) {
+            return Promise.reject(terminalError ??
+                new FiscalDocumentEvaluatorError("the fiscal document evaluator was disposed", "worker_failure"));
+        }
+        sequence += 1;
+        const requestId = `document-${String(sequence)}`;
+        return new Promise((resolve, reject) => {
+            let evaluatorRequestId;
+            try {
+                evaluatorRequestId = parseEvaluatorRequestId(requestJson);
+            }
+            catch (cause) {
+                reject(new FiscalDocumentEvaluatorError(cause instanceof Error ? cause.message : "invalid evaluator request", "protocol_mismatch"));
+                return;
+            }
+            const timer = setTimeout(() => rejectOne(requestId, new FiscalDocumentEvaluatorError(`the fiscal document worker did not answer within ${String(timeoutMs)} ms`, "worker_failure")), timeoutMs);
+            pending.set(requestId, { resolve, reject, timer, evaluatorRequestId });
+            postEvaluation(requestId, requestJson, rejectOne);
+        });
+    };
+    return {
+        evaluate,
+        dispose: () => {
+            if (disposed) {
+                return;
+            }
+            disposed = true;
+            rejectAll(new FiscalDocumentEvaluatorError("the fiscal document evaluator was disposed", "worker_failure"));
+            worker.removeEventListener?.("message", onMessage);
+            worker.removeEventListener?.("error", onWorkerError);
+            worker.removeEventListener?.("messageerror", onMessageError);
+            worker.terminate?.();
+        },
+    };
+}
+function parseEvaluatorRequestId(requestJson) {
+    const parsed = JSON.parse(requestJson);
+    if (typeof parsed.request_id !== "string") {
+        throw new Error("missing evaluator request id");
+    }
+    return parsed.request_id;
+}
+function workerRequestId(candidate) {
+    if (typeof candidate !== "object" || candidate === null || Array.isArray(candidate)) {
+        return null;
+    }
+    const requestId = candidate.request_id;
+    return typeof requestId === "string" ? requestId : null;
+}
+function createDefaultWorker() {
+    if (typeof Worker !== "function") {
+        throw new FiscalDocumentEvaluatorError("no browser Worker runtime is available", "runtime_unavailable");
+    }
+    return new Worker(new URL("./document-worker.js", import.meta.url), { type: "module" });
+}

package/dist/fiscal-delivery.d.ts

@@ -0,0 +1,12 @@
+import { type FiscalDeliveryResource } from "./generated/index.ts";
+import type { Client } from "./generated-operation-client.ts";
+export type FiscalDeliveryCreateCommand = {
+    readonly accountClaimUrl?: string;
+    readonly fiscalOperationId: string;
+    readonly idempotencyKey: string;
+    readonly recipientEmail: string;
+    readonly signal?: AbortSignal;
+};
+export declare function createFiscalDeliveryResource(client: Client, command: FiscalDeliveryCreateCommand): Promise<FiscalDeliveryResource>;
+export declare function getFiscalDeliveryResource(client: Client, deliveryId: string, signal: AbortSignal | undefined): Promise<FiscalDeliveryResource | undefined>;
+//# sourceMappingURL=fiscal-delivery.d.ts.map

package/dist/fiscal-delivery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fiscal-delivery.d.ts","sourceRoot":"","sources":["../src/fiscal-delivery.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,sBAAsB,EAG5B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iCAAiC,CAAC;AAI9D,MAAM,MAAM,2BAA2B,GAAG;IACxC,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;CAC/B,CAAC;AAEF,wBAAsB,4BAA4B,CAChD,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,2BAA2B,GACnC,OAAO,CAAC,sBAAsB,CAAC,CAwBjC;AAED,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,WAAW,GAAG,SAAS,GAC9B,OAAO,CAAC,sBAAsB,GAAG,SAAS,CAAC,CAsB7C"}

package/dist/fiscal-delivery.js

@@ -0,0 +1,45 @@
+import { createFiscalDelivery, retrieveFiscalDelivery, zCreateFiscalDeliveryRequest, } from "./generated/index.js";
+import { isExpectedNotFoundProblem, throwGeneratedProblem } from "./generated-problem.js";
+import { isValidIdempotencyKey } from "./idempotency-key.js";
+export async function createFiscalDeliveryResource(client, command) {
+    if (command.fiscalOperationId.trim() === "") {
+        throw new TypeError("fiscalOperationId must not be blank");
+    }
+    if (!isValidIdempotencyKey(command.idempotencyKey)) {
+        throw new TypeError("idempotencyKey must contain 16 to 255 allowed characters");
+    }
+    const body = zCreateFiscalDeliveryRequest.parse({
+        fiscal_operation_id: command.fiscalOperationId,
+        recipient_email: command.recipientEmail,
+        ...(command.accountClaimUrl === undefined
+            ? {}
+            : { account_claim_url: command.accountClaimUrl }),
+    });
+    const response = await createFiscalDelivery({
+        client,
+        body,
+        headers: { "idempotency-key": command.idempotencyKey },
+        ...(command.signal === undefined ? {} : { signal: command.signal }),
+    });
+    if (response.status !== 200 && response.status !== 201) {
+        throwGeneratedProblem(response, "Fiscal delivery creation failed");
+    }
+    return response.body;
+}
+export async function getFiscalDeliveryResource(client, deliveryId, signal) {
+    if (deliveryId.trim() === "") {
+        throw new TypeError("deliveryId must not be blank");
+    }
+    const response = await retrieveFiscalDelivery({
+        client,
+        path: { fiscal_delivery_id: deliveryId },
+        ...(signal === undefined ? {} : { signal }),
+    });
+    if (isExpectedNotFoundProblem(response, "fiscal_delivery_not_found", "Fiscal delivery lookup failed")) {
+        return;
+    }
+    if (response.status !== 200) {
+        throwGeneratedProblem(response, "Fiscal delivery lookup failed");
+    }
+    return response.body;
+}