@observablehq/notebook-kit 1.6.2 → 1.7.0

package/dist/package.json

@@ -5,7 +5,7 @@
         "type": "git",
         "url": "git+https://github.com/observablehq/notebook-kit.git"
     },
-    "version": "1.6.2",
+    "version": "1.7.0",
     "type": "module",
     "scripts": {
         "test": "vitest",
@@ -73,8 +73,10 @@
         "@types/markdown-it": "^14.1.2",
         "bun-types": "^1.2.20",
         "eslint": "^9.29.0",
+        "exceljs": "^4.4.0",
         "globals": "^16.2.0",
         "htl": "^0.3.1",
+        "jszip": "^3.10.1",
         "postgres": "^3.4.9",
         "snowflake-sdk": "^2.4.0",
         "tsx": "^4.20.3",

package/dist/src/runtime/index.d.ts

@@ -94,8 +94,10 @@ export declare class NotebookRuntime {
                 arrow(): Promise<any>;
                 arquero(options?: any): Promise<any>;
                 parquet(): Promise<any>;
+                zip(): Promise<import("./stdlib/zip.js").ZipArchive>;
                 xml(mimeType?: DOMParserSupportedType): Promise<Document>;
                 html(): Promise<Document>;
+                xlsx(): Promise<import("./stdlib/xlsx.js").Workbook>;
             };
         };
         Generators: () => typeof import("./stdlib/generators/index.js");

package/dist/src/runtime/stdlib/fileAttachment.d.ts

@@ -84,8 +84,10 @@ export declare abstract class AbstractFile implements FileAttachment {
     arrow(): Promise<any>;
     arquero(options?: any): Promise<any>;
     parquet(): Promise<any>;
+    zip(): Promise<import("./zip.js").ZipArchive>;
     xml(mimeType?: DOMParserSupportedType): Promise<Document>;
     html(): Promise<Document>;
+    xlsx(): Promise<import("./xlsx.js").Workbook>;
 }
 declare class FileAttachmentImpl extends AbstractFile {
     href: string;

package/dist/src/runtime/stdlib/fileAttachment.js

@@ -155,12 +155,20 @@ export class AbstractFile {
         const [Arrow, Parquet, buffer] = await Promise.all([import("https://cdn.jsdelivr.net/npm/apache-arrow@17.0.0/+esm"), import("https://cdn.jsdelivr.net/npm/parquet-wasm/+esm").then(async (Parquet) => (await Parquet.default("https://cdn.jsdelivr.net/npm/parquet-wasm/esm/parquet_wasm_bg.wasm"), Parquet)), this.arrayBuffer()]); // prettier-ignore
         return Arrow.tableFromIPC(Parquet.readParquet(new Uint8Array(buffer)).intoIPCStream());
     }
+    async zip() {
+        const [{ ZipArchive }, buffer] = await Promise.all([import("./zip.js"), this.arrayBuffer()]);
+        return ZipArchive.from(buffer);
+    }
     async xml(mimeType = "application/xml") {
         return new DOMParser().parseFromString(await this.text(), mimeType);
     }
     async html() {
         return this.xml("text/html");
     }
+    async xlsx() {
+        const [{ Workbook }, buffer] = await Promise.all([import("./xlsx.js"), this.arrayBuffer()]);
+        return Workbook.load(buffer);
+    }
 }
 // TODO Replace this with static analysis of files.
 function guessMimeType(name) {

package/dist/src/runtime/stdlib/index.d.ts

@@ -84,8 +84,10 @@ export declare const library: {
             arrow(): Promise<any>;
             arquero(options?: any): Promise<any>;
             parquet(): Promise<any>;
+            zip(): Promise<import("./zip.js").ZipArchive>;
             xml(mimeType?: DOMParserSupportedType): Promise<Document>;
             html(): Promise<Document>;
+            xlsx(): Promise<import("./xlsx.js").Workbook>;
         };
     };
     Generators: () => typeof Generators;

package/dist/src/runtime/stdlib/xlsx.d.ts

@@ -0,0 +1,14 @@
+import Excel from "https://cdn.jsdelivr.net/npm/exceljs/+esm";
+export declare class Workbook {
+    private readonly _;
+    readonly sheetNames: string[];
+    constructor(workbook: Excel.Workbook);
+    static load(buffer: ArrayBuffer): Promise<Workbook>;
+    sheet(name: string | number, options?: ExtractOptions): any[] & {
+        columns: any[];
+    };
+}
+export interface ExtractOptions {
+    range?: string;
+    headers?: boolean;
+}

package/dist/src/runtime/stdlib/xlsx.js

@@ -0,0 +1,119 @@
+import Excel from "https://cdn.jsdelivr.net/npm/exceljs/+esm";
+export class Workbook {
+    constructor(workbook) {
+        Object.defineProperties(this, {
+            _: { value: workbook },
+            sheetNames: { value: workbook.worksheets.map((s) => s.name), enumerable: true }
+        });
+    }
+    static async load(buffer) {
+        const workbook = new Excel.Workbook();
+        await workbook.xlsx.load(buffer);
+        return new Workbook(workbook);
+    }
+    sheet(name, options) {
+        const sname = typeof name === "number"
+            ? this.sheetNames[name]
+            : this.sheetNames.includes((name = `${name}`))
+                ? name
+                : null;
+        if (sname == null)
+            throw new Error(`Sheet not found: ${name}`);
+        const sheet = this._.getWorksheet(sname);
+        if (!sheet)
+            throw new Error(`Sheet not found: ${name}`);
+        return extract(sheet, options);
+    }
+}
+function extract(sheet, { range, headers } = {}) {
+    let [[c0, r0], [c1, r1]] = parseRange(range, sheet); // eslint-disable-line prefer-const
+    const headerRow = headers ? sheet.getRow(++r0) : null;
+    const nameset = new Set(["#"]);
+    for (let n = c0; n <= c1; n++) {
+        const value = headerRow ? valueOf(headerRow.findCell(n + 1)) : null;
+        let name = (value && value + "") || toColumn(n);
+        while (nameset.has(name))
+            name += "_";
+        nameset.add(name);
+    }
+    const names = new Array(c0).concat(Array.from(nameset));
+    const columns = names.filter(() => true); // Filter sparse columns
+    const output = Object.assign(new Array(r1 - r0 + 1), { columns });
+    for (let r = r0; r <= r1; r++) {
+        const row = (output[r - r0] = Object.create(null, { "#": { value: r + 1 } }));
+        const _row = sheet.getRow(r + 1);
+        if (_row.hasValues)
+            for (let c = c0; c <= c1; c++) {
+                const value = valueOf(_row.findCell(c + 1));
+                if (value != null)
+                    row[names[c + 1]] = value;
+            }
+    }
+    return output;
+}
+function isPrimitive(value) {
+    return !value || typeof value !== "object" || value instanceof Date;
+}
+function isFormula(value) {
+    return "formula" in value || "sharedFormula" in value;
+}
+function isRichText(value) {
+    return "richText" in value;
+}
+function isHyperlink(value) {
+    return "hyperlink" in value;
+}
+function valueOf(cell) {
+    if (!cell)
+        return;
+    const { value } = cell;
+    if (isPrimitive(value))
+        return value;
+    if (isFormula(value))
+        return isPrimitive(value.result) ? value.result : NaN; // result is error
+    if (isRichText(value))
+        return richText(value);
+    if (isHyperlink(value))
+        return hyperlink(value);
+    return undefined; // value is error
+}
+function richText(value) {
+    return value.richText.map((d) => d.text).join("");
+}
+function hyperlink({ hyperlink, text }) {
+    return hyperlink && hyperlink !== text ? `${hyperlink} ${text}` : text;
+}
+function parseRange(specifier = ":", { columnCount, rowCount }) {
+    specifier = `${specifier}`;
+    if (!specifier.match(/^[A-Z]*\d*:[A-Z]*\d*$/))
+        throw new Error("Malformed range specifier");
+    const [[c0 = 0, r0 = 0], [c1 = columnCount - 1, r1 = rowCount - 1]] = specifier
+        .split(":")
+        .map(fromCellReference);
+    return [
+        [c0, r0],
+        [c1, r1]
+    ];
+}
+// Returns the default column name for a zero-based column index.
+// For example: 0 -> "A", 1 -> "B", 25 -> "Z", 26 -> "AA", 27 -> "AB".
+function toColumn(c) {
+    let sc = "";
+    c++;
+    do
+        sc = String.fromCharCode(64 + (c % 26 || 26)) + sc;
+    while ((c = Math.floor((c - 1) / 26)));
+    return sc;
+}
+// Returns the zero-based indexes from a cell reference.
+// For example: "A1" -> [0, 0], "B2" -> [1, 1], "AA10" -> [26, 9].
+function fromCellReference(specifier) {
+    const [, sc, sr] = specifier.match(/^([A-Z]*)(\d*)$/);
+    let c = 0;
+    if (sc) {
+        for (let i = 0; i < sc.length; i++) {
+            c += Math.pow(26, sc.length - i - 1) * (sc.charCodeAt(i) - 64);
+        }
+    }
+    return [c ? c - 1 : undefined, sr ? +sr - 1 : undefined];
+}

package/dist/src/runtime/stdlib/zip.d.ts

@@ -0,0 +1,21 @@
+import JSZip from "https://cdn.jsdelivr.net/npm/jszip/+esm";
+import { AbstractFile } from "./fileAttachment.js";
+export declare class ZipArchive {
+    private readonly _;
+    readonly filenames: string[];
+    constructor(archive: JSZip);
+    static from(buffer: ArrayBuffer): Promise<ZipArchive>;
+    file(path: string): ZipArchiveEntry;
+}
+declare class ZipArchiveEntry extends AbstractFile {
+    href: string;
+    private readonly _;
+    private _url;
+    constructor(object: JSZip.JSZipObject);
+    url(): Promise<string>;
+    blob(): Promise<Blob>;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    text(): Promise<string>;
+    json(): Promise<any>;
+}
+export {};

package/dist/src/runtime/stdlib/zip.js

@@ -0,0 +1,49 @@
+import JSZip from "https://cdn.jsdelivr.net/npm/jszip/+esm";
+import { AbstractFile } from "./fileAttachment.js";
+export class ZipArchive {
+    constructor(archive) {
+        Object.defineProperties(this, {
+            _: { value: archive },
+            filenames: { value: Object.keys(archive.files).filter((name) => !archive.files[name].dir) }
+        });
+    }
+    static async from(buffer) {
+        return new ZipArchive(await JSZip.loadAsync(buffer));
+    }
+    file(path) {
+        const object = this._.file((path = `${path}`));
+        if (!object || object.dir)
+            throw new Error(`file not found: ${path}`);
+        return new ZipArchiveEntry(object);
+    }
+}
+class ZipArchiveEntry extends AbstractFile {
+    constructor(object) {
+        super(undefined, object.name);
+        Object.defineProperty(this, "href", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        }); // async
+        Object.defineProperties(this, {
+            _: { value: object },
+            _url: { writable: true }
+        });
+    }
+    async url() {
+        return this._url || (this._url = this.blob().then(URL.createObjectURL));
+    }
+    async blob() {
+        return this._.async("blob");
+    }
+    async arrayBuffer() {
+        return this._.async("arraybuffer");
+    }
+    async text() {
+        return this._.async("text");
+    }
+    async json() {
+        return JSON.parse(await this.text());
+    }
+}

package/package.json

@@ -5,7 +5,7 @@
     "type": "git",
     "url": "git+https://github.com/observablehq/notebook-kit.git"
   },
-  "version": "1.6.2",
+  "version": "1.7.0",
   "type": "module",
   "scripts": {
     "test": "vitest",
@@ -73,8 +73,10 @@
     "@types/markdown-it": "^14.1.2",
     "bun-types": "^1.2.20",
     "eslint": "^9.29.0",
+    "exceljs": "^4.4.0",
     "globals": "^16.2.0",
     "htl": "^0.3.1",
+    "jszip": "^3.10.1",
     "postgres": "^3.4.9",
     "snowflake-sdk": "^2.4.0",
     "tsx": "^4.20.3",