@cj-tech-master/excelts 3.1.0 → 4.0.0-canary.20260103013222.0e5d37f

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

@@ -0,0 +1,101 @@
+import { XmlStream } from "../utils/xml-stream.js";
+import { RelType } from "../xlsx/rel-type.js";
+import { colCache } from "../utils/col-cache.js";
+import { CommentXform } from "../xlsx/xform/comment/comment-xform.js";
+import { VmlShapeXform } from "../xlsx/xform/comment/vml-shape-xform.js";
+import { commentsPath, commentsRelTargetFromWorksheet, vmlDrawingPath, vmlDrawingRelTargetFromWorksheet } from "../utils/ooxml-paths.js";
+class SheetCommentsWriter {
+    constructor(worksheet, sheetRelsWriter, options) {
+        // in a workbook, each sheet will have a number
+        this.id = options.id;
+        this.count = 0;
+        this._worksheet = worksheet;
+        this._workbook = options.workbook;
+        this._sheetRelsWriter = sheetRelsWriter;
+    }
+    get commentsStream() {
+        if (!this._commentsStream) {
+            this._commentsStream = this._workbook._openStream(commentsPath(this.id));
+        }
+        return this._commentsStream;
+    }
+    get vmlStream() {
+        if (!this._vmlStream) {
+            this._vmlStream = this._workbook._openStream(vmlDrawingPath(this.id));
+        }
+        return this._vmlStream;
+    }
+    _addRelationships() {
+        const commentRel = {
+            Type: RelType.Comments,
+            Target: commentsRelTargetFromWorksheet(this.id)
+        };
+        this._sheetRelsWriter.addRelationship(commentRel);
+        const vmlDrawingRel = {
+            Type: RelType.VmlDrawing,
+            Target: vmlDrawingRelTargetFromWorksheet(this.id)
+        };
+        this.vmlRelId = this._sheetRelsWriter.addRelationship(vmlDrawingRel);
+    }
+    _addCommentRefs() {
+        this._workbook.commentRefs.push({
+            commentName: `comments${this.id}`,
+            vmlDrawing: `vmlDrawing${this.id}`
+        });
+    }
+    _writeOpen() {
+        this.commentsStream.write('<?xml version="1.0" encoding="UTF-8" standalone="yes"?>' +
+            '<comments xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">' +
+            "<authors><author>Author</author></authors>" +
+            "<commentList>");
+        this.vmlStream.write('<?xml version="1.0" encoding="UTF-8"?>' +
+            '<xml xmlns:o="urn:schemas-microsoft-com:office:office" xmlns:v="urn:schemas-microsoft-com:vml" xmlns:x="urn:schemas-microsoft-com:office:excel">' +
+            '<o:shapelayout v:ext="edit">' +
+            '<o:idmap v:ext="edit" data="1" />' +
+            "</o:shapelayout>" +
+            '<v:shapetype id="_x0000_t202" coordsize="21600,21600" o:spt="202" path="m,l,21600r21600,l21600,xe">' +
+            '<v:stroke joinstyle="miter" />' +
+            '<v:path gradientshapeok="t" o:connecttype="rect" />' +
+            "</v:shapetype>");
+    }
+    _writeComment(comment, index) {
+        const commentXform = new CommentXform();
+        const commentsXmlStream = new XmlStream();
+        commentXform.render(commentsXmlStream, comment);
+        this.commentsStream.write(commentsXmlStream.xml);
+        const vmlShapeXform = new VmlShapeXform();
+        const vmlXmlStream = new XmlStream();
+        vmlShapeXform.render(vmlXmlStream, comment, index);
+        this.vmlStream.write(vmlXmlStream.xml);
+    }
+    _writeClose() {
+        this.commentsStream.write("</commentList></comments>");
+        this.vmlStream.write("</xml>");
+    }
+    addComments(comments) {
+        if (comments && comments.length) {
+            if (!this.startedData) {
+                this._worksheet.comments = [];
+                this._writeOpen();
+                this._addRelationships();
+                this._addCommentRefs();
+                this.startedData = true;
+            }
+            comments.forEach(item => {
+                item.refAddress = colCache.decodeAddress(item.ref);
+            });
+            comments.forEach(comment => {
+                this._writeComment(comment, this.count);
+                this.count += 1;
+            });
+        }
+    }
+    commit() {
+        if (this.count) {
+            this._writeClose();
+            this.commentsStream.end();
+            this.vmlStream.end();
+        }
+    }
+}
+export { SheetCommentsWriter };

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 };