@lofcz/tikz 0.2.2 → 0.2.3

package/runtime/dist/types.d.ts

@@ -101,9 +101,9 @@ export interface MetaPostOptions {
     /** Defer engine glue and MetaPost WASM until used. MetaPost version fields in creation
      * metadata remain empty in this mode. No cross-request cache is required. */
     lazy?: boolean;
-    /** Default for latex()'s snapshot option. Node: 'auto' (tikz.fmt from local files is free). Browser: 'none',
-     *  because the 5.8 MB format does not compress and costs more to download than the files it replaces
-     *  (2.5 MB gzipped); set 'auto' when many TikZ figures amortise it or the format is already cached. */
+    /** Default for latex()'s snapshot option: Node 'auto', browser 'none'. Browser hosts
+     * may enable 'auto' when shipping precompiled formats (the @lofcz/tikz browser entry does).
+     * Auto uses basic TikZ when available and the full format for explicit plotting packages. */
     snapshot?: 'auto' | 'none';
 }
 export type OutputFormat = 'svg' | 'eps' | 'json' | 'none';

package/runtime/dist/vfs/lazyfs.d.ts

@@ -12,6 +12,7 @@ export interface EmscriptenFS {
     mkdir(path: string, mode?: number): void;
     writeFile(path: string, data: Uint8Array | string, opts?: {
         encoding?: string;
+        canOwn?: boolean;
     }): void;
     readFile(path: string, opts?: {
         encoding?: 'binary' | 'utf8';
@@ -50,7 +51,7 @@ export declare function isUnloadedLazy(FS: EmscriptenFS, path: string): boolean;
 /** Force-load a lazy node (no-op for ordinary files). */
 export declare function ensureLoaded(FS: EmscriptenFS, path: string): void;
 /** Write a text or binary file, creating directories as needed. */
-export declare function writeFileDeep(FS: EmscriptenFS, path: string, data: Uint8Array | string): void;
+export declare function writeFileDeep(FS: EmscriptenFS, path: string, data: Uint8Array | string, canOwn?: boolean): void;
 /**
  * Record every file opened for writing from now on (absolute paths, into the
  * returned set). The engine's open syscall reaches the filesystem through
@@ -60,3 +61,7 @@ export declare function writeFileDeep(FS: EmscriptenFS, path: string, data: Uint
 export declare function trackWrites(FS: EmscriptenFS): Set<string>;
 /** Recursively collect regular files under `dir` (used to harvest artifacts). */
 export declare function listFiles(FS: EmscriptenFS, dir: string): string[];
+/** Borrow a completed MEMFS file; never retain a view into a module's WASM heap. */
+export declare function completedFileBytes(FS: EmscriptenFS, path: string, heap?: Uint8Array): Uint8Array;
+/** Auxiliary inputs remain available, but are copied only if the consumer opens them. */
+export declare function writeDeferredFile(FS: EmscriptenFS, path: string, size: number, load: () => Uint8Array): void;

package/runtime/dist/vfs/lazyfs.js

@@ -82,7 +82,7 @@ export function ensureLoaded(FS, path) {
     }
 }
 /** Write a text or binary file, creating directories as needed. */
-export function writeFileDeep(FS, path, data) {
+export function writeFileDeep(FS, path, data, canOwn = false) {
     const i = path.lastIndexOf('/');
     if (i > 0)
         mkdirp(FS, path.slice(0, i));
@@ -92,7 +92,7 @@ export function writeFileDeep(FS, path, data) {
         }
         catch { /* ignore */ }
     }
-    FS.writeFile(path, data);
+    FS.writeFile(path, data, { canOwn });
 }
 /**
  * Record every file opened for writing from now on (absolute paths, into the
@@ -130,4 +130,19 @@ export function listFiles(FS, dir) {
     walk(dir);
     return out;
 }
+/** Borrow a completed MEMFS file; never retain a view into a module's WASM heap. */
+export function completedFileBytes(FS, path, heap) {
+    const node = FS.lookupPath(path).node;
+    if (heap && node.contents instanceof Uint8Array && node.contents.buffer !== heap.buffer &&
+        Number.isSafeInteger(node.usedBytes) && node.usedBytes >= 0 && node.usedBytes <= node.contents.length)
+        return node.contents.subarray(0, node.usedBytes);
+    return FS.readFile(path, { encoding: 'binary' });
+}
+/** Auxiliary inputs remain available, but are copied only if the consumer opens them. */
+export function writeDeferredFile(FS, path, size, load) {
+    mkdirp(FS, path.slice(0, path.lastIndexOf('/')) || '/');
+    if (FS.analyzePath(path).exists)
+        FS.unlink(path);
+    createLazyFile(FS, path, size, () => load().slice());
+}
 //# sourceMappingURL=lazyfs.js.map

package/src/browser-worker.js

@@ -1,7 +1,7 @@
 import { MetaPost } from '../runtime/dist/index.js';
 
 try {
-  const engine = await MetaPost.create({ worker: false, lazy: true, logLevel: 'silent' });
+  const engine = await MetaPost.create({ worker: false, lazy: true, snapshot: 'auto', logLevel: 'silent' });
   self.onmessage = async ({ data: { source: code, maxOutputBytes } }) => {
     try {
       const source = /^\s*\\documentclass\b/m.test(code) ? code : String.raw`\documentclass[tikz,border=6pt]{standalone}