@flyfish-dev/dwf-viewer 0.5.0

package/dist/format/zip.d.ts

@@ -0,0 +1,30 @@
+import type { InflateProvider } from './types.js';
+export interface ZipEntry {
+    name: string;
+    compressedSize: number;
+    uncompressedSize: number;
+    compressionMethod: number;
+    crc32: number;
+    localHeaderOffset: number;
+    centralHeaderOffset: number;
+    flags: number;
+    lastModTime: number;
+    lastModDate: number;
+    comment: string;
+}
+export declare class ZipPackage {
+    readonly entries: ZipEntry[];
+    readonly entryMap: Map<string, ZipEntry>;
+    readonly archiveBase: number;
+    private readonly bytes;
+    private readonly inflater;
+    private readonly cache;
+    private constructor();
+    static open(bytes: Uint8Array, inflater?: InflateProvider): ZipPackage;
+    has(name: string): boolean;
+    get(name: string): ZipEntry | undefined;
+    find(predicate: (entry: ZipEntry) => boolean): ZipEntry | undefined;
+    findAll(predicate: (entry: ZipEntry) => boolean): ZipEntry[];
+    read(entryOrName: ZipEntry | string): Promise<Uint8Array>;
+}
+export declare function looksLikeZip(bytes: Uint8Array): boolean;

package/dist/format/zip.js

@@ -0,0 +1,141 @@
+import { BrowserInflateProvider } from './inflate.js';
+import { decodeUtf8, normalizePath } from './util.js';
+const SIG_EOCD = 0x06054b50;
+const SIG_CENTRAL = 0x02014b50;
+const SIG_LOCAL = 0x04034b50;
+export class ZipPackage {
+    constructor(bytes, entries, archiveBase, inflater) {
+        this.entryMap = new Map();
+        this.cache = new Map();
+        this.bytes = bytes;
+        this.entries = entries;
+        this.archiveBase = archiveBase;
+        this.inflater = inflater ?? new BrowserInflateProvider();
+        for (const e of entries)
+            this.entryMap.set(normalizePath(e.name), e);
+    }
+    static open(bytes, inflater) {
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        const eocdOffset = findEocd(view);
+        if (eocdOffset < 0)
+            throw new Error('ZIP end-of-central-directory record was not found. This is not a DWF 6+/DWFx ZIP package.');
+        const diskNo = u16(view, eocdOffset + 4);
+        const cdDiskNo = u16(view, eocdOffset + 6);
+        if (diskNo !== 0 || cdDiskNo !== 0)
+            throw new Error('Multi-disk ZIP archives are not supported.');
+        const entryCount = u16(view, eocdOffset + 10);
+        const centralSize = u32(view, eocdOffset + 12);
+        const centralOffset = u32(view, eocdOffset + 16);
+        // ZIP offsets are relative to the beginning of the ZIP archive. DWF files may prepend a textual
+        // DWF header before the actual PK stream, so derive the base by locating the central directory.
+        let archiveBase = 0;
+        let centralAbs = centralOffset;
+        if (u32(view, centralAbs) !== SIG_CENTRAL) {
+            const maxShift = Math.max(0, eocdOffset - centralSize - 1024 * 1024);
+            let found = -1;
+            for (let p = eocdOffset - centralSize; p >= maxShift; p--) {
+                if (p >= 0 && u32(view, p) === SIG_CENTRAL) {
+                    found = p;
+                    break;
+                }
+            }
+            if (found < 0)
+                throw new Error('ZIP central directory could not be located.');
+            centralAbs = found;
+            archiveBase = centralAbs - centralOffset;
+        }
+        const entries = [];
+        let ptr = centralAbs;
+        for (let i = 0; i < entryCount; i++) {
+            if (u32(view, ptr) !== SIG_CENTRAL)
+                throw new Error(`Bad central directory signature at ${ptr}.`);
+            const flags = u16(view, ptr + 8);
+            const method = u16(view, ptr + 10);
+            const lastModTime = u16(view, ptr + 12);
+            const lastModDate = u16(view, ptr + 14);
+            const crc32 = u32(view, ptr + 16);
+            const compressedSize = u32(view, ptr + 20);
+            const uncompressedSize = u32(view, ptr + 24);
+            const nameLen = u16(view, ptr + 28);
+            const extraLen = u16(view, ptr + 30);
+            const commentLen = u16(view, ptr + 32);
+            const localHeaderOffset = u32(view, ptr + 42);
+            const nameBytes = bytes.subarray(ptr + 46, ptr + 46 + nameLen);
+            const commentBytes = bytes.subarray(ptr + 46 + nameLen + extraLen, ptr + 46 + nameLen + extraLen + commentLen);
+            const name = normalizePath(decodeFileName(nameBytes, flags));
+            const comment = decodeFileName(commentBytes, flags);
+            if (!name.endsWith('/')) {
+                entries.push({ name, compressedSize, uncompressedSize, compressionMethod: method, crc32, localHeaderOffset, centralHeaderOffset: ptr - archiveBase, flags, lastModTime, lastModDate, comment });
+            }
+            ptr += 46 + nameLen + extraLen + commentLen;
+        }
+        return new ZipPackage(bytes, entries, archiveBase, inflater);
+    }
+    has(name) {
+        return this.entryMap.has(normalizePath(name));
+    }
+    get(name) {
+        return this.entryMap.get(normalizePath(name));
+    }
+    find(predicate) {
+        return this.entries.find(predicate);
+    }
+    findAll(predicate) {
+        return this.entries.filter(predicate);
+    }
+    async read(entryOrName) {
+        const entry = typeof entryOrName === 'string' ? this.get(entryOrName) : entryOrName;
+        if (!entry)
+            throw new Error(`ZIP entry not found: ${entryOrName}`);
+        const cached = this.cache.get(entry.name);
+        if (cached)
+            return cached;
+        const view = new DataView(this.bytes.buffer, this.bytes.byteOffset, this.bytes.byteLength);
+        const localAbs = this.archiveBase + entry.localHeaderOffset;
+        if (u32(view, localAbs) !== SIG_LOCAL)
+            throw new Error(`Bad local header signature for ${entry.name}.`);
+        const nameLen = u16(view, localAbs + 26);
+        const extraLen = u16(view, localAbs + 28);
+        const dataStart = localAbs + 30 + nameLen + extraLen;
+        const compressed = this.bytes.subarray(dataStart, dataStart + entry.compressedSize);
+        let out;
+        if (entry.compressionMethod === 0)
+            out = compressed.slice();
+        else if (entry.compressionMethod === 8)
+            out = await this.inflater.inflateRaw(compressed);
+        else
+            throw new Error(`Unsupported ZIP compression method ${entry.compressionMethod} for ${entry.name}.`);
+        if (entry.uncompressedSize !== 0 && out.byteLength !== entry.uncompressedSize) {
+            // Some producers write zero or ZIP64 placeholders; only enforce when central directory has a normal size.
+            if (entry.uncompressedSize < 0xffffffff) {
+                throw new Error(`ZIP entry size mismatch for ${entry.name}: expected ${entry.uncompressedSize}, got ${out.byteLength}.`);
+            }
+        }
+        this.cache.set(entry.name, out);
+        return out;
+    }
+}
+export function looksLikeZip(bytes) {
+    if (bytes.byteLength < 22)
+        return false;
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    if (u32(view, 0) === SIG_LOCAL)
+        return true;
+    return findEocd(view) >= 0;
+}
+function findEocd(view) {
+    const min = Math.max(0, view.byteLength - 0xffff - 22);
+    for (let p = view.byteLength - 22; p >= min; p--) {
+        if (u32(view, p) === SIG_EOCD)
+            return p;
+    }
+    return -1;
+}
+function decodeFileName(bytes, flags) {
+    // Bit 11 indicates UTF-8. For legacy DWF names, ASCII-compatible decoding is usually enough.
+    if ((flags & (1 << 11)) !== 0)
+        return decodeUtf8(bytes);
+    return Array.from(bytes, b => String.fromCharCode(b)).join('');
+}
+function u16(view, offset) { return view.getUint16(offset, true); }
+function u32(view, offset) { return view.getUint32(offset, true); }

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export { openDwfDocument } from './format/open.js';
+export { ZipPackage, looksLikeZip } from './format/zip.js';
+export { BrowserInflateProvider } from './format/inflate.js';
+export { DwfViewer } from './viewer/DwfViewer.js';
+export type { DwfViewerOptions, LoadOptions } from './viewer/DwfViewer.js';
+export { PageRenderer } from './render/PageRenderer.js';
+export { WasmRasterBackend } from './wasm/WasmRasterBackend.js';
+export { WebGlW2dBackend } from './render/WebGlW2dBackend.js';
+export { ThreeW3dRenderer } from './render/ThreeW3dRenderer.js';
+export { createThreeGroupFromW3d } from './render/ThreeJsSceneAdapter.js';
+export type { LoadedDwfDocument, PageData, XpsPageData, W2dTextPageData, ImagePageData, UnsupportedPageData, W3dPageData, W3dModelData, W3dMeshData, W2dPrimitive } from './format/document.js';
+export type { DwfDocument, RenderablePage, Diagnostic, RenderStats, OpenOptions, InflateProvider } from './format/types.js';

package/dist/index.js

@@ -0,0 +1,9 @@
+export { openDwfDocument } from './format/open.js';
+export { ZipPackage, looksLikeZip } from './format/zip.js';
+export { BrowserInflateProvider } from './format/inflate.js';
+export { DwfViewer } from './viewer/DwfViewer.js';
+export { PageRenderer } from './render/PageRenderer.js';
+export { WasmRasterBackend } from './wasm/WasmRasterBackend.js';
+export { WebGlW2dBackend } from './render/WebGlW2dBackend.js';
+export { ThreeW3dRenderer } from './render/ThreeW3dRenderer.js';
+export { createThreeGroupFromW3d } from './render/ThreeJsSceneAdapter.js';

package/dist/render/PageRenderer.d.ts

@@ -0,0 +1,27 @@
+import { type RenderStats } from '../format/types.js';
+import type { LoadedDwfDocument } from '../format/document.js';
+export interface GenericRenderOptions {
+    zoom?: number;
+    panX?: number;
+    panY?: number;
+    preferWebgl?: boolean;
+    preferWasm?: boolean;
+    wasmUrl?: string;
+    background?: string;
+    maxGpuCacheBytes?: number;
+    maxCachedScenes?: number;
+    webglCanvas?: HTMLCanvasElement;
+    yaw?: number;
+    pitch?: number;
+}
+export declare class PageRenderer {
+    private readonly document;
+    private xps?;
+    private w2d?;
+    private w3d?;
+    constructor(document: LoadedDwfDocument);
+    render(pageIndex: number, canvas: HTMLCanvasElement, options?: GenericRenderOptions): Promise<RenderStats>;
+    dispose(): void;
+    private renderImage;
+    private renderUnsupported;
+}

package/dist/render/PageRenderer.js

@@ -0,0 +1,92 @@
+import { actionableDiagnostics, diag } from '../format/types.js';
+import { blobToImage } from '../format/util.js';
+import { XpsRenderer } from './XpsRenderer.js';
+import { W2dRenderer } from './W2dRenderer.js';
+import { ThreeW3dRenderer } from './ThreeW3dRenderer.js';
+export class PageRenderer {
+    constructor(document) {
+        this.document = document;
+    }
+    async render(pageIndex, canvas, options = {}) {
+        const page = this.document.pageData[pageIndex];
+        if (!page)
+            throw new Error(`Page index out of range: ${pageIndex}`);
+        if (page.kind !== 'w2d-text' && page.kind !== 'w3d-model' && options.webglCanvas)
+            options.webglCanvas.style.visibility = 'hidden';
+        if (page.kind === 'xps-fixed-page') {
+            this.xps ?? (this.xps = new XpsRenderer(this.document));
+            return await this.xps.render(page, canvas, options);
+        }
+        if (page.kind === 'w2d-text') {
+            this.w2d ?? (this.w2d = new W2dRenderer());
+            return await this.w2d.render(page, canvas, options);
+        }
+        if (page.kind === 'w3d-model') {
+            this.w3d ?? (this.w3d = new ThreeW3dRenderer());
+            return await this.w3d.render(page, canvas, options);
+        }
+        if (page.kind === 'image')
+            return await this.renderImage(page, canvas, options);
+        return this.renderUnsupported(page, canvas, options);
+    }
+    dispose() {
+        this.w2d?.dispose();
+        this.w3d?.dispose();
+    }
+    async renderImage(page, canvas, options) {
+        const zip = this.document.zip;
+        if (!zip)
+            throw new Error('Image page requires a ZIP package.');
+        const ctx = canvas.getContext('2d');
+        if (!ctx)
+            throw new Error('CanvasRenderingContext2D is not available.');
+        ctx.save();
+        ctx.setTransform(1, 0, 0, 1, 0, 0);
+        ctx.fillStyle = options.background ?? '#ffffff';
+        ctx.fillRect(0, 0, canvas.width, canvas.height);
+        ctx.restore();
+        const image = await blobToImage(await zip.read(page.sourcePath), page.mediaType);
+        const iw = 'width' in image ? image.width : image.naturalWidth;
+        const ih = 'height' in image ? image.height : image.naturalHeight;
+        const scale = Math.min(canvas.width / Math.max(1, iw), canvas.height / Math.max(1, ih)) * (options.zoom ?? 1);
+        const w = iw * scale, h = ih * scale;
+        const x = (canvas.width - w) / 2 + (options.panX ?? 0);
+        const y = (canvas.height - h) / 2 + (options.panY ?? 0);
+        ctx.drawImage(image, x, y, w, h);
+        return { backend: 'image', commands: 1, warnings: actionableDiagnostics(page.diagnostics) };
+    }
+    renderUnsupported(page, canvas, options) {
+        const ctx = canvas.getContext('2d');
+        if (!ctx)
+            throw new Error('CanvasRenderingContext2D is not available.');
+        ctx.save();
+        ctx.setTransform(1, 0, 0, 1, 0, 0);
+        ctx.fillStyle = options.background ?? '#ffffff';
+        ctx.fillRect(0, 0, canvas.width, canvas.height);
+        ctx.fillStyle = '#111827';
+        ctx.font = '16px sans-serif';
+        wrapText(ctx, page.name, 32, 48, canvas.width - 64, 24);
+        ctx.font = '13px sans-serif';
+        ctx.fillStyle = '#92400e';
+        wrapText(ctx, page.reason, 32, 88, canvas.width - 64, 20);
+        ctx.restore();
+        return { backend: 'unsupported', commands: 0, warnings: [...page.diagnostics, diag('warning', 'PAGE_UNSUPPORTED', page.reason, page.sourcePath)] };
+    }
+}
+function wrapText(ctx, text, x, y, maxWidth, lineHeight) {
+    const words = text.split(/\s+/);
+    let line = '';
+    for (const word of words) {
+        const test = line ? `${line} ${word}` : word;
+        if (ctx.measureText(test).width > maxWidth && line) {
+            ctx.fillText(line, x, y);
+            line = word;
+            y += lineHeight;
+        }
+        else {
+            line = test;
+        }
+    }
+    if (line)
+        ctx.fillText(line, x, y);
+}

package/dist/render/ThreeJsSceneAdapter.d.ts

@@ -0,0 +1,29 @@
+import type { W3dMaterialData, W3dPageData, W3dModelData, W3dTextureData } from '../format/document.js';
+export interface ThreeLikeNamespace {
+    Group: new () => any;
+    BufferGeometry: new () => any;
+    BufferAttribute: new (array: ArrayLike<number>, itemSize: number) => any;
+    MeshStandardMaterial: new (options?: Record<string, unknown>) => any;
+    MeshBasicMaterial?: new (options?: Record<string, unknown>) => any;
+    LineBasicMaterial?: new (options?: Record<string, unknown>) => any;
+    Mesh: new (geometry: any, material: any) => any;
+    LineSegments?: new (geometry: any, material: any) => any;
+    Color?: new (r: number, g: number, b: number) => any;
+    DoubleSide?: number;
+}
+export interface ThreeAdapterOptions {
+    doubleSide?: boolean;
+    roughness?: number;
+    metalness?: number;
+    showFeatureEdges?: boolean;
+    edgeColor?: number | string;
+    textureResolver?: (texture: W3dTextureData, material: W3dMaterialData) => unknown;
+}
+/**
+ * Convert a decoded DWFx/W3D model into a real THREE.Group.
+ *
+ * This helper accepts the THREE namespace as an argument so the core viewer remains
+ * buildable offline without bundling npm dependencies.  Pass `textureResolver` to
+ * bind DWFx package image resources to Three.js Texture objects in your app layer.
+ */
+export declare function createThreeGroupFromW3d(pageOrModel: W3dPageData | W3dModelData, THREE: ThreeLikeNamespace, options?: ThreeAdapterOptions): any;

package/dist/render/ThreeJsSceneAdapter.js

@@ -0,0 +1,52 @@
+/**
+ * Convert a decoded DWFx/W3D model into a real THREE.Group.
+ *
+ * This helper accepts the THREE namespace as an argument so the core viewer remains
+ * buildable offline without bundling npm dependencies.  Pass `textureResolver` to
+ * bind DWFx package image resources to Three.js Texture objects in your app layer.
+ */
+export function createThreeGroupFromW3d(pageOrModel, THREE, options = {}) {
+    const model = pageOrModel.model ?? pageOrModel;
+    const group = new THREE.Group();
+    group.name = model.title ?? 'DWFx W3D Model';
+    const materialById = new Map((model.materials ?? []).map(m => [m.id, m]));
+    const textureById = new Map((model.textures ?? []).map(t => [t.id, t]));
+    for (const mesh of model.meshes) {
+        const geometry = new THREE.BufferGeometry();
+        geometry.setAttribute('position', new THREE.BufferAttribute(mesh.positions, 3));
+        if (mesh.normals)
+            geometry.setAttribute('normal', new THREE.BufferAttribute(mesh.normals, 3));
+        geometry.setIndex(new THREE.BufferAttribute(mesh.indices, 1));
+        const srcMaterial = mesh.materialId ? materialById.get(mesh.materialId) : undefined;
+        const color = srcMaterial?.color ?? mesh.color ?? [0.72, 0.74, 0.78];
+        const materialOptions = {
+            color: THREE.Color ? new THREE.Color(color[0], color[1], color[2]) : undefined,
+            roughness: srcMaterial?.roughness ?? options.roughness ?? 0.55,
+            metalness: srcMaterial?.metalness ?? options.metalness ?? 0.04,
+            transparent: srcMaterial?.opacity !== undefined && srcMaterial.opacity < 1,
+            opacity: srcMaterial?.opacity ?? 1
+        };
+        if ((options.doubleSide || srcMaterial?.doubleSided) && THREE.DoubleSide !== undefined)
+            materialOptions.side = THREE.DoubleSide;
+        const tex = srcMaterial?.textureId ? textureById.get(srcMaterial.textureId) : undefined;
+        if (tex && options.textureResolver)
+            materialOptions.map = options.textureResolver(tex, srcMaterial);
+        const material = new THREE.MeshStandardMaterial(materialOptions);
+        const obj = new THREE.Mesh(geometry, material);
+        obj.name = mesh.name;
+        obj.userData = { sourceStart: mesh.sourceStart, sourceEnd: mesh.sourceEnd, decodeKind: mesh.decodeKind, selectionRefs: mesh.selectionRefs, nodeId: mesh.nodeId, materialId: mesh.materialId };
+        group.add(obj);
+        if (options.showFeatureEdges !== false && mesh.edgeIndices && THREE.LineSegments && THREE.LineBasicMaterial) {
+            const edgeGeometry = new THREE.BufferGeometry();
+            edgeGeometry.setAttribute('position', new THREE.BufferAttribute(mesh.positions, 3));
+            edgeGeometry.setIndex(new THREE.BufferAttribute(mesh.edgeIndices, 1));
+            const edgeMaterial = new THREE.LineBasicMaterial({ color: options.edgeColor ?? 0x111111, transparent: true, opacity: 0.52 });
+            const edges = new THREE.LineSegments(edgeGeometry, edgeMaterial);
+            edges.name = `${mesh.name} feature edges`;
+            edges.userData = { sourceMeshId: mesh.id, selectionRefs: mesh.selectionRefs, nodeId: mesh.nodeId };
+            group.add(edges);
+        }
+    }
+    group.userData = { bounds: model.bounds, stats: model.stats, sourcePath: model.sourcePath, sceneTree: model.sceneTree, pmi: model.pmi, views: model.views, textures: model.textures, materials: model.materials };
+    return group;
+}

package/dist/render/ThreeW3dRenderer.d.ts

@@ -0,0 +1,24 @@
+import { type RenderStats } from '../format/types.js';
+import type { W3dPageData } from '../format/document.js';
+import type { GenericRenderOptions } from './PageRenderer.js';
+export interface W3dCameraOptions {
+    yaw?: number;
+    pitch?: number;
+    zoom?: number;
+    panX?: number;
+    panY?: number;
+}
+export declare class ThreeW3dRenderer {
+    private gl?;
+    private program?;
+    private edgeProgram?;
+    private cache;
+    private currentCanvas?;
+    render(page: W3dPageData, overlayCanvas: HTMLCanvasElement, options?: GenericRenderOptions): Promise<RenderStats>;
+    dispose(): void;
+    private ensureContext;
+    private ensureProgram;
+    private ensureEdgeProgram;
+    private evictScenes;
+    private ensureScene;
+}