@cj-tech-master/excelts 4.0.0 → 4.0.1-canary.20260104072032.0453bbe

package/dist/browser/modules/excel/stream/sheet-rels-writer.d.ts

@@ -0,0 +1,45 @@
+interface Hyperlink {
+    address: string;
+    target: string;
+}
+interface Relationship {
+    Type: string;
+    Target: string;
+    TargetMode?: string;
+}
+declare class HyperlinksProxy {
+    writer: SheetRelsWriter;
+    constructor(sheetRelsWriter: SheetRelsWriter);
+    push(hyperlink: Hyperlink): void;
+}
+interface SheetRelsWriterOptions {
+    id: number;
+    workbook: any;
+}
+declare class SheetRelsWriter {
+    id: number;
+    count: number;
+    _hyperlinks: Array<{
+        rId: string;
+        address: string;
+    }>;
+    _workbook: any;
+    _stream?: any;
+    _hyperlinksProxy?: HyperlinksProxy;
+    constructor(options: SheetRelsWriterOptions);
+    get stream(): any;
+    get length(): number;
+    each(fn: (hyperlink: {
+        rId: string;
+        address: string;
+    }) => void): void;
+    get hyperlinksProxy(): HyperlinksProxy;
+    addHyperlink(hyperlink: Hyperlink): void;
+    addMedia(media: Relationship): string;
+    addRelationship(rel: Relationship): string;
+    commit(): void;
+    _writeOpen(): void;
+    _writeRelationship(relationship: Relationship): string;
+    _writeClose(): void;
+}
+export { SheetRelsWriter };

package/dist/browser/modules/excel/stream/sheet-rels-writer.js

@@ -0,0 +1,91 @@
+import { xmlEncode } from "../../../utils/utils.browser.js";
+import { RelType } from "../xlsx/rel-type.js";
+import { worksheetRelsPath } from "../utils/ooxml-paths.js";
+class HyperlinksProxy {
+    constructor(sheetRelsWriter) {
+        this.writer = sheetRelsWriter;
+    }
+    push(hyperlink) {
+        this.writer.addHyperlink(hyperlink);
+    }
+}
+class SheetRelsWriter {
+    constructor(options) {
+        // in a workbook, each sheet will have a number
+        this.id = options.id;
+        // count of all relationships
+        this.count = 0;
+        // keep record of all hyperlinks
+        this._hyperlinks = [];
+        this._workbook = options.workbook;
+    }
+    get stream() {
+        if (!this._stream) {
+            this._stream = this._workbook._openStream(worksheetRelsPath(this.id));
+        }
+        return this._stream;
+    }
+    get length() {
+        return this._hyperlinks.length;
+    }
+    each(fn) {
+        return this._hyperlinks.forEach(fn);
+    }
+    get hyperlinksProxy() {
+        return this._hyperlinksProxy || (this._hyperlinksProxy = new HyperlinksProxy(this));
+    }
+    addHyperlink(hyperlink) {
+        // Write to stream
+        const relationship = {
+            Target: hyperlink.target,
+            Type: RelType.Hyperlink,
+            TargetMode: "External"
+        };
+        const rId = this._writeRelationship(relationship);
+        // store sheet stuff for later
+        this._hyperlinks.push({
+            rId,
+            address: hyperlink.address
+        });
+    }
+    addMedia(media) {
+        return this._writeRelationship(media);
+    }
+    addRelationship(rel) {
+        return this._writeRelationship(rel);
+    }
+    commit() {
+        if (this.count) {
+            // write xml utro
+            this._writeClose();
+            // and close stream
+            this.stream.end();
+        }
+    }
+    // ================================================================================
+    _writeOpen() {
+        this.stream.write(`<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+       <Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">`);
+    }
+    _writeRelationship(relationship) {
+        if (!this.count) {
+            this._writeOpen();
+        }
+        const rId = `rId${++this.count}`;
+        if (relationship.TargetMode) {
+            this.stream.write(`<Relationship Id="${rId}"` +
+                ` Type="${relationship.Type}"` +
+                ` Target="${xmlEncode(relationship.Target)}"` +
+                ` TargetMode="${relationship.TargetMode}"` +
+                "/>");
+        }
+        else {
+            this.stream.write(`<Relationship Id="${rId}" Type="${relationship.Type}" Target="${relationship.Target}"/>`);
+        }
+        return rId;
+    }
+    _writeClose() {
+        this.stream.write("</Relationships>");
+    }
+}
+export { SheetRelsWriter };

package/dist/browser/modules/excel/stream/workbook-reader.browser.d.ts

@@ -0,0 +1,169 @@
+/**
+ * WorkbookReader - Browser Streaming Workbook Reader
+ *
+ * This module contains the full shared implementation for the streaming
+ * workbook reader and a browser-compatible `WorkbookReader` that buffers
+ * waiting worksheets in memory.
+ *
+ * Node.js uses `workbook-reader.ts`, which extends the same base implementation
+ * with filesystem-specific features (filename input + temp-file buffering).
+ */
+import { EventEmitter, Readable } from "@stream";
+import { iterateStream } from "@excel/utils/iterate-stream";
+import { StylesXform } from "@excel/xlsx/xform/style/styles-xform";
+import type { WorksheetState, Font, WorkbookProperties } from "@excel/types";
+import { WorksheetReader } from "@excel/stream/worksheet-reader";
+import { HyperlinkReader, type Hyperlink } from "@excel/stream/hyperlink-reader";
+export interface InternalWorksheetOptions {
+    worksheets?: "emit" | "ignore" | "prep";
+    sharedStrings?: "cache" | "emit" | "ignore";
+    hyperlinks?: "cache" | "emit" | "ignore";
+    styles?: "cache" | "ignore";
+    entries?: "emit" | "ignore";
+}
+export interface SharedStringRichText {
+    richText: Array<{
+        font: Partial<Font> | null;
+        text: string | null;
+    }>;
+}
+export type SharedStringValue = string | SharedStringRichText;
+export interface WorkbookRelationship {
+    Id: string;
+    Target: string;
+    Type?: string;
+}
+export interface SheetMetadata {
+    id: number;
+    name: string;
+    state?: WorksheetState;
+    rId: string;
+}
+export interface WorkbookModel {
+    sheets?: SheetMetadata[];
+    properties?: Partial<WorkbookProperties>;
+    views?: unknown[];
+    definedNames?: unknown[];
+}
+export interface WorkbookPropertiesXform {
+    model?: Partial<WorkbookProperties>;
+}
+export interface EntryPayload {
+    type: "shared-strings" | "styles" | "workbook" | "worksheet" | "hyperlinks";
+    id?: string;
+}
+export type ParseEventType = "shared-strings" | "worksheet" | "hyperlinks";
+export interface SharedStringEvent {
+    eventType: "shared-strings";
+    value: {
+        index: number;
+        text: SharedStringValue;
+    };
+}
+export interface WorksheetReadyEvent<TWorksheetReader> {
+    eventType: "worksheet";
+    value: TWorksheetReader;
+}
+export interface HyperlinksEvent<THyperlinkReader> {
+    eventType: "hyperlinks";
+    value: THyperlinkReader;
+}
+export type ParseEvent<TWorksheetReader, THyperlinkReader> = SharedStringEvent | WorksheetReadyEvent<TWorksheetReader> | HyperlinksEvent<THyperlinkReader>;
+export interface WaitingWorksheetEntry {
+    eventType: "waiting-worksheet";
+    sheetNo: string;
+    entry: any;
+}
+export type CommonInput = Uint8Array | ArrayBuffer | Readable | ReadableStream<Uint8Array>;
+export interface WorkbookReaderOptions {
+    worksheets?: "emit" | "ignore";
+    sharedStrings?: "cache" | "emit" | "ignore";
+    hyperlinks?: "cache" | "emit" | "ignore";
+    styles?: "cache" | "ignore";
+    entries?: "emit" | "ignore";
+}
+/** Constructor type for WorksheetReader/HyperlinkReader */
+export interface ReaderConstructor<TReader, TWorkbook> {
+    new (params: {
+        workbook: TWorkbook;
+        id: number;
+        iterator: AsyncIterable<never>;
+        options: InternalWorksheetOptions;
+    }): TReader;
+}
+export declare abstract class WorkbookReaderBase<TInput, TWorksheetReader extends EventEmitter & {
+    id?: number | string;
+    name?: string;
+    state?: WorksheetState;
+}, THyperlinkReader extends EventEmitter & {
+    hyperlinks?: Record<string, Hyperlink>;
+}, TWaitingWorksheet = unknown> extends EventEmitter {
+    input: TInput;
+    options: {
+        worksheets: "emit" | "ignore";
+        sharedStrings: "cache" | "emit" | "ignore";
+        hyperlinks: "cache" | "emit" | "ignore";
+        styles: "cache" | "ignore";
+        entries: "emit" | "ignore";
+    };
+    styles: StylesXform;
+    stream?: Readable;
+    sharedStrings?: SharedStringValue[];
+    workbookRels?: WorkbookRelationship[];
+    properties?: WorkbookPropertiesXform;
+    model?: WorkbookModel;
+    protected _hyperlinkReadersBySheetNo?: Record<string, THyperlinkReader>;
+    protected _workbookRelIdByTarget?: Record<string, string>;
+    protected _sheetByRelId?: Record<string, SheetMetadata>;
+    getHyperlinkReader(sheetNo: number | string): THyperlinkReader | undefined;
+    getHyperlink(sheetNo: number | string, rId: string): Hyperlink | undefined;
+    getHyperlinkTarget(sheetNo: number | string, rId: string): string | undefined;
+    protected WorksheetReaderClass: ReaderConstructor<TWorksheetReader, this>;
+    protected HyperlinkReaderClass: ReaderConstructor<THyperlinkReader, this>;
+    constructor(input: TInput, options: WorkbookReaderOptions, WorksheetReaderClass: ReaderConstructor<TWorksheetReader, any>, HyperlinkReaderClass: ReaderConstructor<THyperlinkReader, any>);
+    _getStream(input: TInput): Readable;
+    abstract _storeWaitingWorksheet(sheetNo: string, entry: any): Promise<TWaitingWorksheet>;
+    abstract _processWaitingWorksheets(waitingWorksheets: TWaitingWorksheet[]): AsyncIterableIterator<WorksheetReadyEvent<TWorksheetReader>>;
+    _cleanupWaitingWorksheets(_waitingWorksheets: TWaitingWorksheet[]): void;
+    _createWorksheetReader(params: {
+        id: number;
+        iterator: AsyncIterable<unknown>;
+        options: InternalWorksheetOptions;
+    }): TWorksheetReader;
+    _createHyperlinkReader(params: {
+        id: number;
+        iterator: AsyncIterable<unknown>;
+        options: InternalWorksheetOptions;
+    }): THyperlinkReader;
+    read(input?: TInput, options?: WorkbookReaderOptions): Promise<void>;
+    [Symbol.asyncIterator](): AsyncIterableIterator<TWorksheetReader>;
+    parse(input?: TInput, options?: WorkbookReaderOptions): AsyncIterableIterator<ParseEvent<TWorksheetReader, THyperlinkReader>>;
+    _emitEntry(payload: EntryPayload): void;
+    _parseRels(entry: Parameters<typeof iterateStream>[0]): Promise<void>;
+    _parseWorkbook(entry: Parameters<typeof iterateStream>[0]): Promise<void>;
+    _parseSharedStrings(entry: Parameters<typeof iterateStream>[0]): AsyncIterableIterator<{
+        index: number;
+        text: SharedStringValue;
+    }>;
+    _parseStyles(entry: Parameters<typeof iterateStream>[0]): Promise<void>;
+    _parseWorksheet(iterator: AsyncIterable<unknown>, sheetNo: string): IterableIterator<WorksheetReadyEvent<TWorksheetReader>>;
+    protected _parseHyperlinks(iterator: AsyncIterable<unknown>, sheetNo: string): AsyncIterableIterator<HyperlinksEvent<THyperlinkReader>>;
+    protected _parseEntries(stream: Readable): AsyncIterableIterator<ParseEvent<TWorksheetReader, THyperlinkReader> | WaitingWorksheetEntry>;
+}
+export declare const WorkbookReaderOptionsSchema: {
+    readonly worksheets: readonly ["emit", "ignore"];
+    readonly sharedStrings: readonly ["cache", "emit", "ignore"];
+    readonly hyperlinks: readonly ["cache", "emit", "ignore"];
+    readonly styles: readonly ["cache", "ignore"];
+    readonly entries: readonly ["emit", "ignore"];
+};
+interface WaitingWorksheet {
+    sheetNo: string;
+    data: Uint8Array[];
+}
+declare class WorkbookReader extends WorkbookReaderBase<CommonInput, WorksheetReader, HyperlinkReader, WaitingWorksheet> {
+    constructor(input: CommonInput, options?: WorkbookReaderOptions);
+    _storeWaitingWorksheet(sheetNo: string, entry: any): Promise<WaitingWorksheet>;
+    _processWaitingWorksheets(waitingWorksheets: WaitingWorksheet[]): AsyncIterableIterator<WorksheetReadyEvent<WorksheetReader>>;
+}
+export { WorkbookReader };