@docmentis/udoc-wasm 0.0.0-stage → 0.8.0

package/dist/index.d.ts

@@ -0,0 +1,58 @@
+import { WasmSession } from "./wasm/udoc.js";
+import type { GoogleFontFamily, SessionConfig, UrlFont } from "./wasm/udoc.js";
+export * from "./wasm/udoc.js";
+export { default } from "./wasm/udoc.js";
+export { GOOGLE_FONT_CATALOG } from "./google-font-catalog.js";
+export { OFFICE_COMPATIBLE_FONTS } from "./office-compatible-fonts.js";
+export { CSS2_ENDPOINT, createFontFetchMemory, fetchFontBinaries } from "./font-fulfill.js";
+export type { Fetcher, FontFetchMemory } from "./font-fulfill.js";
+export { UDocError } from "./error.js";
+export type { UDocErrorCode, UDocErrorDetail } from "./error.js";
+/**
+ * Where this package's office-compatible fonts are served: the directory its
+ * `dist/` is served as, which each font's path resolves against (a host's own
+ * copy, a CDN), or each path's own URL (`meta-url`'s `bundledFontUrls`, which
+ * a bundler emits file by file).
+ */
+export type FontLocation = string | Readonly<Record<string, string>>;
+/** The {@link OFFICE_COMPATIBLE_FONTS}, each at its URL in `fonts`. */
+export declare function officeCompatibleFontsAt(fonts: FontLocation): UrlFont[];
+/**
+ * Start a session as the glue's `startSession` does, offering it this
+ * package's fonts: the {@link OFFICE_COMPATIBLE_FONTS} by URL, from `fonts`,
+ * and `googleFontFamilies` — the {@link GOOGLE_FONT_CATALOG} unless given, `[]`
+ * for no Google Fonts at all. Rejects, with no session left behind, when the
+ * license refuses or the list isn't a list of `GoogleFontFamily`.
+ *
+ * It shadows the glue's export of the same name, so every host that starts a
+ * session through this module offers both unless it says otherwise.
+ */
+export declare function startSession(config: SessionConfig, fonts: FontLocation, googleFontFamilies?: readonly GoogleFontFamily[]): Promise<WasmSession>;
+declare module "./wasm/udoc.js" {
+    interface WasmSession {
+        readonly portable: DocNamespace<"portable">;
+        readonly presentation: DocNamespace<"presentation">;
+        readonly spreadsheet: DocNamespace<"spreadsheet">;
+        readonly wordprocessing: DocNamespace<"wordprocessing">;
+    }
+}
+/** `session.<Doc>`: its methods' names parsed into levels. */
+type DocNamespace<Doc extends string> = Level<Extract<keyof WasmSession, `__${Doc}_${string}`>, `__${Doc}`, []>;
+/** The level at the name prefix `At`, among the methods `K`; `Taken` holds the
+ *  arguments the calls on the way took. */
+type Level<K extends keyof WasmSession & string, At extends string, Taken extends unknown[]> = {
+    readonly [S in PropertyStep<K, At> | CallStep<K, At> | LastStep<K, At>]: S extends LastStep<K, At> ? Last<WasmSession[`${At}_${S}` & keyof WasmSession], Taken> : S extends CallStep<K, At> ? (arg: Argument<WasmSession[Extract<K, `${At}__${S}_${string}`>], Taken>) => Level<K, `${At}__${S}`, [...Taken, unknown]> : Level<K, `${At}_${S}`, Taken>;
+};
+/** The property steps at `At`: `_step` followed by more. */
+type PropertyStep<K extends string, At extends string> = K extends `${At}_${infer S}_${string}` ? S extends "" ? never : S : never;
+/** The call steps at `At`: `__step` followed by more. */
+type CallStep<K extends string, At extends string> = K extends `${At}__${infer S}_${string}` ? S extends "" ? never : S : never;
+/** The last steps at `At`: `_step` ending the name. */
+type LastStep<K extends string, At extends string> = K extends `${At}_${infer S}` ? S extends "" | `${string}_${string}` ? never : S : never;
+/** The argument a call step takes: the parameter of each method under it after
+ *  the ones `Taken` already covers. */
+type Argument<M, Taken extends unknown[]> = M extends (...args: infer P) => unknown ? P[Taken["length"]] : never;
+/** A last step: its method, less the parameters the calls on the way took. */
+type Last<M, Taken extends unknown[]> = Taken extends [] ? M : M extends (...args: infer P) => infer R ? (...args: Drop<P, Taken>) => R : never;
+/** `P` without as many leading elements as `Taken` has. */
+type Drop<P extends unknown[], Taken extends unknown[]> = Taken extends [unknown, ...infer T] ? P extends [unknown, ...infer R] ? Drop<R, T> : [] : P;

package/dist/index.js

@@ -0,0 +1,150 @@
+// The package root: the wasm-bindgen glue (`wasm/udoc.js`), re-exported whole,
+// with each doc type's reads grouped under `session.<doc>` on its `WasmSession`.
+//
+// The glue declares every read flat, as a private `__<doc>…` method. This module
+// groups them by name onto the class's prototype, so every session
+// `startSession` returns carries them, however a host loaded this module —
+// nothing wraps the session. A read's name is its path:
+//
+//   __portable_model_root_pageIds()         session.portable.model.root.pageIds()
+//   __portable_model__page_shapeInfo(p, s)  session.portable.model.page(p).shapeInfo(s)
+//
+// After `__<doc>`, `_step` is a property and `__step` a call taking one
+// argument. The last step is always a call, written `_step`, taking every
+// argument left. A step is a middle step or a last one, never both. The runtime
+// below parses the names off the prototype and the types parse them out of
+// `udoc.d.ts`, so a new read in Rust needs no line here.
+//
+// The glue is imported by relative path, not by package name, so this module
+// still resolves it when served unbundled from a CDN or a host's own directory.
+//
+// Beside the glue it exports the two font offers the package ships — the
+// office-compatible fonts and the Google font catalog, which its own
+// `startSession` offers every session it starts — what fills a session's font
+// orders, and `UDocError`, the error every failure is reported as.
+import { WasmSession, startSession as startGlueSession } from "./wasm/udoc.js";
+import { UDocError } from "./error.js";
+import { GOOGLE_FONT_CATALOG } from "./google-font-catalog.js";
+import { OFFICE_COMPATIBLE_FONTS } from "./office-compatible-fonts.js";
+export * from "./wasm/udoc.js";
+export { default } from "./wasm/udoc.js";
+export { GOOGLE_FONT_CATALOG } from "./google-font-catalog.js";
+export { OFFICE_COMPATIBLE_FONTS } from "./office-compatible-fonts.js";
+export { CSS2_ENDPOINT, createFontFetchMemory, fetchFontBinaries } from "./font-fulfill.js";
+export { UDocError } from "./error.js";
+/** The {@link OFFICE_COMPATIBLE_FONTS}, each at its URL in `fonts`. */
+export function officeCompatibleFontsAt(fonts) {
+    return OFFICE_COMPATIBLE_FONTS.map((font) => {
+        const url = typeof fonts === "string" ? new URL(font.url, fonts).href : fonts[font.url];
+        if (url === undefined)
+            throw new UDocError("invalidRequest", `no URL is given for the font ${font.url}`);
+        return { ...font, url };
+    });
+}
+/**
+ * Start a session as the glue's `startSession` does, offering it this
+ * package's fonts: the {@link OFFICE_COMPATIBLE_FONTS} by URL, from `fonts`,
+ * and `googleFontFamilies` — the {@link GOOGLE_FONT_CATALOG} unless given, `[]`
+ * for no Google Fonts at all. Rejects, with no session left behind, when the
+ * license refuses or the list isn't a list of `GoogleFontFamily`.
+ *
+ * It shadows the glue's export of the same name, so every host that starts a
+ * session through this module offers both unless it says otherwise.
+ */
+export async function startSession(config, fonts, googleFontFamilies = GOOGLE_FONT_CATALOG) {
+    const officeCompatibleFonts = officeCompatibleFontsAt(fonts);
+    const session = await startGlueSession(config);
+    try {
+        session.setGoogleFontFamilies(googleFontFamilies);
+        session.registerUrlFonts(officeCompatibleFonts);
+    }
+    catch (error) {
+        session.free();
+        throw error;
+    }
+    return session;
+}
+/** The doc types grouped under `session.<doc>` — named, not found, because
+ *  wasm-bindgen's own `__destroy_into_raw` sits on the same prototype. */
+const DOCS = [
+    "portable",
+    "presentation",
+    "spreadsheet",
+    "wordprocessing",
+];
+/** One separator and the step it introduces: `_step` or `__step`. */
+const SEGMENT = /(__?)([^_]+)/y;
+/** The steps under `session.<doc>`, parsed from the names of its methods. */
+function parse(doc) {
+    const root = new Map();
+    const prefix = `__${doc}`;
+    for (const name of Object.getOwnPropertyNames(WasmSession.prototype)) {
+        if (!name.startsWith(`${prefix}_`))
+            continue;
+        const method = Object.getOwnPropertyDescriptor(WasmSession.prototype, name).value;
+        const path = segments(name, prefix.length);
+        let steps = root;
+        path.forEach(([separator, step], i) => {
+            const existing = steps.get(step);
+            if (i === path.length - 1) {
+                if (separator !== "_")
+                    throw new Error(`WasmSession.${name}: the last step is written \`_${step}\``);
+                if (existing)
+                    throw new Error(`WasmSession.${name}: \`${step}\` is already a step`);
+                steps.set(step, { kind: "last", method });
+                return;
+            }
+            const kind = separator === "_" ? "property" : "call";
+            if (!existing) {
+                const next = new Map();
+                steps.set(step, { kind, next });
+                steps = next;
+                return;
+            }
+            if (existing.kind === "last" || existing.kind !== kind) {
+                throw new Error(`WasmSession.${name}: \`${step}\` is already a different step`);
+            }
+            steps = existing.next;
+        });
+    }
+    return root;
+}
+/** `name` from `from` on, as `[separator, step]` pairs. */
+function segments(name, from) {
+    const found = [];
+    SEGMENT.lastIndex = from;
+    let at = from;
+    for (let match = SEGMENT.exec(name); match; match = SEGMENT.exec(name)) {
+        found.push([match[1], match[2]]);
+        at = SEGMENT.lastIndex;
+    }
+    if (found.length === 0 || at !== name.length)
+        throw new Error(`WasmSession.${name}: not a namespace path`);
+    return found;
+}
+/** `steps` bound to `session`, `args` holding what the calls on the way took. */
+function bind(steps, session, args) {
+    const level = {};
+    for (const [name, step] of steps) {
+        switch (step.kind) {
+            case "property":
+                level[name] = bind(step.next, session, args);
+                break;
+            case "call":
+                level[name] = (arg) => bind(step.next, session, [...args, arg]);
+                break;
+            case "last":
+                level[name] = (...rest) => step.method.apply(session, [...args, ...rest]);
+                break;
+        }
+    }
+    return level;
+}
+for (const doc of DOCS) {
+    const steps = parse(doc);
+    Object.defineProperty(WasmSession.prototype, doc, {
+        get() {
+            return bind(steps, this, []);
+        },
+    });
+}

package/dist/meta-url.d.ts

@@ -0,0 +1,3 @@
+export declare const bundledWasmUrl: string;
+/** Each office-compatible font's URL, by its path in `OFFICE_COMPATIBLE_FONTS`. */
+export declare const bundledFontUrls: Readonly<Record<string, string>>;

package/dist/meta-url.js

@@ -0,0 +1,46 @@
+// `import.meta.url`-based resolution of the bundled WASM artifacts.
+//
+// `scripts/copy-wasm.mjs` copies the wasm-bindgen output into `dist/wasm/`, and
+// `scripts/copy-fonts.mjs` the office-compatible fonts into `dist/fonts/`, so
+// they sit next to the compiled JS. We resolve each against this module's URL,
+// which keeps the package self-contained: the browser at runtime, or Node,
+// finds them beside this module, and a consumer's bundler emits each one as an
+// asset, since every file is named by its own literal `new URL(…,
+// import.meta.url)` — a pattern Vite and webpack follow, where a computed path
+// would not be.
+//
+// Isolated in its own file and loaded **only via dynamic `import()`** (from
+// udoc-ui's `worker/wasm-loader.ts`) so environments that don't support
+// `import.meta` at parse time (e.g. StackBlitz's turbo_modules) don't choke.
+function abs(u) {
+    // Some bundlers emit a root-relative path; make it absolute against the
+    // current origin so a worker (different base URL) resolves it the same way.
+    if (u.startsWith("/") && typeof globalThis.location !== "undefined") {
+        return globalThis.location.origin + u;
+    }
+    return u;
+}
+export const bundledWasmUrl = abs(new URL("./wasm/udoc_bg.wasm", import.meta.url).href);
+/** Each office-compatible font's URL, by its path in `OFFICE_COMPATIBLE_FONTS`. */
+export const bundledFontUrls = {
+    "fonts/LiberationSans-Regular.ttf": abs(new URL("./fonts/LiberationSans-Regular.ttf", import.meta.url).href),
+    "fonts/LiberationSans-Bold.ttf": abs(new URL("./fonts/LiberationSans-Bold.ttf", import.meta.url).href),
+    "fonts/LiberationSans-Italic.ttf": abs(new URL("./fonts/LiberationSans-Italic.ttf", import.meta.url).href),
+    "fonts/LiberationSans-BoldItalic.ttf": abs(new URL("./fonts/LiberationSans-BoldItalic.ttf", import.meta.url).href),
+    "fonts/LiberationSerif-Regular.ttf": abs(new URL("./fonts/LiberationSerif-Regular.ttf", import.meta.url).href),
+    "fonts/LiberationSerif-Bold.ttf": abs(new URL("./fonts/LiberationSerif-Bold.ttf", import.meta.url).href),
+    "fonts/LiberationSerif-Italic.ttf": abs(new URL("./fonts/LiberationSerif-Italic.ttf", import.meta.url).href),
+    "fonts/LiberationSerif-BoldItalic.ttf": abs(new URL("./fonts/LiberationSerif-BoldItalic.ttf", import.meta.url).href),
+    "fonts/LiberationMono-Regular.ttf": abs(new URL("./fonts/LiberationMono-Regular.ttf", import.meta.url).href),
+    "fonts/LiberationMono-Bold.ttf": abs(new URL("./fonts/LiberationMono-Bold.ttf", import.meta.url).href),
+    "fonts/LiberationMono-Italic.ttf": abs(new URL("./fonts/LiberationMono-Italic.ttf", import.meta.url).href),
+    "fonts/LiberationMono-BoldItalic.ttf": abs(new URL("./fonts/LiberationMono-BoldItalic.ttf", import.meta.url).href),
+    "fonts/Carlito-Regular.ttf": abs(new URL("./fonts/Carlito-Regular.ttf", import.meta.url).href),
+    "fonts/Carlito-Bold.ttf": abs(new URL("./fonts/Carlito-Bold.ttf", import.meta.url).href),
+    "fonts/Carlito-Italic.ttf": abs(new URL("./fonts/Carlito-Italic.ttf", import.meta.url).href),
+    "fonts/Carlito-BoldItalic.ttf": abs(new URL("./fonts/Carlito-BoldItalic.ttf", import.meta.url).href),
+    "fonts/Caladea-Regular.ttf": abs(new URL("./fonts/Caladea-Regular.ttf", import.meta.url).href),
+    "fonts/Caladea-Bold.ttf": abs(new URL("./fonts/Caladea-Bold.ttf", import.meta.url).href),
+    "fonts/Caladea-Italic.ttf": abs(new URL("./fonts/Caladea-Italic.ttf", import.meta.url).href),
+    "fonts/Caladea-BoldItalic.ttf": abs(new URL("./fonts/Caladea-BoldItalic.ttf", import.meta.url).href),
+};

package/dist/office-compatible-fonts.d.ts

@@ -0,0 +1,3 @@
+import type { UrlFont } from "./wasm/udoc.js";
+/** Every face this package ships, each `url` its path in `dist/`. */
+export declare const OFFICE_COMPATIBLE_FONTS: readonly UrlFont[];

package/dist/office-compatible-fonts.js

@@ -0,0 +1,33 @@
+// The metric-compatible office fonts — Liberation, Carlito, Caladea — that a
+// native build of the engine bundles and this wasm build leaves to its host.
+//
+// `scripts/copy-fonts.mjs` copies them from the drawing crate into `dist/fonts/`
+// at build time. Each `url` here is the file's path in `dist/`: `startSession`
+// takes where `dist/` is served, or each file's own URL (`meta-url`'s
+// `bundledFontUrls`), and offers the fonts by URL to every session it starts,
+// so a document fetches only the faces its layout asks for. A host with no
+// fetching offers the same files as bytes as well.
+//
+// Each family is registered under its own true name, never under the Microsoft
+// font it stands in for: mapping Arial → Liberation Sans is the engine's
+// substitute table's job.
+/** The bold / italic variants of a family, and the suffix of each one's file. */
+const STYLES = [
+    ["Regular", false, false],
+    ["Bold", true, false],
+    ["Italic", false, true],
+    ["BoldItalic", true, true],
+];
+/** Each family's true name, and the prefix of its files. */
+const FAMILIES = [
+    ["Liberation Sans", "LiberationSans"],
+    ["Liberation Serif", "LiberationSerif"],
+    ["Liberation Mono", "LiberationMono"],
+    ["Carlito", "Carlito"],
+    ["Caladea", "Caladea"],
+];
+/** Every face this package ships, each `url` its path in `dist/`. */
+export const OFFICE_COMPATIBLE_FONTS = FAMILIES.flatMap(([family, file]) => STYLES.map(([style, bold, italic]) => ({
+    descriptor: { family, bold, italic },
+    url: `fonts/${file}-${style}.ttf`,
+})));