@rdfx/xlsx 0.0.0-stage → 0.0.60

package/dist/AbstractParser.d.ts

@@ -0,0 +1,20 @@
+import type { NamespaceBuilder } from "@rdfjs/namespace";
+import type PrefixMap from "@rdfjs/prefix-map/PrefixMap.js";
+import type { DataFactory, DatasetCoreFactory } from "@rdfjs/types";
+import type { Logger } from "@rdfx/logger";
+import type { Maybe } from "purify-ts";
+export declare abstract class AbstractParser {
+    protected readonly dataFactory: DataFactory;
+    protected readonly datasetFactory: DatasetCoreFactory;
+    protected readonly logger: Logger;
+    protected readonly prefixMap: Maybe<PrefixMap>;
+    protected readonly defaultNamespace: Maybe<NamespaceBuilder>;
+    constructor({ dataFactory, datasetFactory, defaultNamespace, logger, prefixMap, }: {
+        dataFactory: DataFactory;
+        datasetFactory: DatasetCoreFactory;
+        defaultNamespace: Maybe<NamespaceBuilder>;
+        logger: Logger;
+        prefixMap: Maybe<PrefixMap>;
+    });
+}
+//# sourceMappingURL=AbstractParser.d.ts.map

package/dist/AbstractParser.js

@@ -0,0 +1,15 @@
+export class AbstractParser {
+    dataFactory;
+    datasetFactory;
+    logger;
+    prefixMap;
+    defaultNamespace;
+    constructor({ dataFactory, datasetFactory, defaultNamespace, logger, prefixMap, }) {
+        this.dataFactory = dataFactory;
+        this.datasetFactory = datasetFactory;
+        this.defaultNamespace = defaultNamespace;
+        this.logger = logger;
+        this.prefixMap = prefixMap;
+    }
+}
+//# sourceMappingURL=AbstractParser.js.map

package/dist/Cell.d.ts

@@ -0,0 +1,64 @@
+import { type DepParser } from "fast-formula-parser";
+import { Either, type Maybe } from "purify-ts";
+import { CellAddress } from "./CellAddress.js";
+import type { Worksheet } from "./Worksheet.js";
+export declare class Cell {
+    #private;
+    private readonly depParser;
+    private readonly worksheet;
+    /**
+     * Address of this cell.
+     */
+    readonly address: CellAddress;
+    /**
+     * Formula associated with this cell.
+     */
+    readonly formula: Maybe<string>;
+    /**
+     * Hyperlink attached to this cell.
+     */
+    readonly hyperlink: Maybe<Cell.Hyperlink>;
+    /**
+     * Value associated with this cell.
+     */
+    readonly value: Maybe<Cell.Value>;
+    constructor({ address, depParser, formula, hyperlink, value, worksheet, }: {
+        address: CellAddress;
+        depParser: DepParser;
+        formula: Maybe<string>;
+        hyperlink: Maybe<Cell.Hyperlink>;
+        value: Maybe<Cell.Value>;
+        worksheet: Worksheet;
+    });
+    get dependencies(): Either<Error, (CellAddress | Cell)[]>;
+    get dependencyCellAddresses(): Either<Error, readonly CellAddress[]>;
+    /**
+     * SHA-256 sha256 hex digest of this cell.
+     */
+    get sha256(): string;
+    toJSON(): Record<string, unknown>;
+    protected hashRecursive(visitedCellAddresses: Set<string>): string;
+}
+export declare namespace Cell {
+    class Error {
+        readonly value: string;
+        constructor(value: string);
+    }
+    interface Hyperlink {
+        readonly target: string;
+        readonly tooltip: Maybe<string>;
+    }
+    namespace Hyperlink {
+        function toJSON(hyperlink: Hyperlink): {
+            target: string;
+            tooltip?: string;
+        };
+    }
+    type Value = boolean | Error | Date | number | string;
+    namespace Value {
+        function toJSON(value: Value): boolean | number | {
+            error: string;
+        } | string;
+    }
+}
+//# sourceMappingURL=Cell.d.ts.map

package/dist/Cell.js

@@ -0,0 +1,208 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { MAX_COLUMN, MAX_ROW } from "fast-formula-parser";
+import { sha256 } from "js-sha256";
+import { Either } from "purify-ts";
+import { Memoize } from "typescript-memoize";
+import { CellAddress } from "./CellAddress.js";
+export class Cell {
+    depParser;
+    worksheet;
+    #sha256 = null;
+    /**
+     * Address of this cell.
+     */
+    address;
+    /**
+     * Formula associated with this cell.
+     */
+    formula;
+    /**
+     * Hyperlink attached to this cell.
+     */
+    hyperlink;
+    /**
+     * Value associated with this cell.
+     */
+    value;
+    constructor({ address, depParser, formula, hyperlink, value, worksheet, }) {
+        this.address = address;
+        this.depParser = depParser;
+        this.formula = formula;
+        this.hyperlink = hyperlink;
+        this.value = value;
+        this.worksheet = worksheet;
+    }
+    get dependencies() {
+        return this.dependencyCellAddresses.map((dependencyCellAddresses) => dependencyCellAddresses.map((dependencyCellAddress) => this.worksheet.workbook.cell(dependencyCellAddress).orDefault(dependencyCellAddress)));
+    }
+    get dependencyCellAddresses() {
+        const formula = this.formula.extract();
+        if (!formula) {
+            return Either.of([]);
+        }
+        return Either.encase(() => {
+            const dependencyCellAddresses = [];
+            const deps = this.depParser.parse(formula, {
+                // DepParser uses 1-based row and column indices
+                col: this.address.columnIndex + 1,
+                row: this.address.rowIndex + 1,
+                sheet: this.worksheet.name,
+            });
+            for (const dep of deps) {
+                if ("from" in dep) {
+                    for (let row = Math.min(dep.from.row, dep.to.row); row <= Math.max(dep.from.row, dep.to.row); row++) {
+                        for (let col = Math.min(dep.from.col, dep.to.col); col <= Math.max(dep.from.col, dep.to.col); col++) {
+                            dependencyCellAddresses.push(new CellAddress({
+                                columnIndex: col - 1,
+                                rowIndex: row - 1,
+                                worksheetName: dep.sheet ?? this.worksheet.name,
+                            }));
+                        }
+                    }
+                }
+                else {
+                    if (dep.col === MAX_COLUMN || dep.row === MAX_ROW) {
+                        continue;
+                    }
+                    dependencyCellAddresses.push(new CellAddress({
+                        columnIndex: dep.col - 1,
+                        rowIndex: dep.row - 1,
+                        worksheetName: dep.sheet ?? this.worksheet.name,
+                    }));
+                }
+            }
+            return dependencyCellAddresses;
+        });
+    }
+    /**
+     * SHA-256 sha256 hex digest of this cell.
+     */
+    get sha256() {
+        if (this.#sha256 !== null) {
+            return this.#sha256;
+        }
+        return this.hashRecursive(new Set());
+    }
+    toJSON() {
+        const json = {};
+        this.dependencyCellAddresses
+            .ifLeft((error) => {
+            json["dependencies"] = { error: error.message };
+        })
+            .ifRight((dependencies) => {
+            json["dependencies"] = dependencies;
+        });
+        this.formula.ifJust((formula) => {
+            json["formula"] = formula;
+        });
+        this.hyperlink.ifJust((hyperlink) => {
+            json["hyperlink"] = Cell.Hyperlink.toJSON(hyperlink);
+        });
+        this.value.ifJust((value) => {
+            json["value"] = Cell.Value.toJSON(value);
+        });
+        return json;
+    }
+    hashRecursive(visitedCellAddresses) {
+        if (this.#sha256 !== null) {
+            return this.#sha256;
+        }
+        visitedCellAddresses.add(this.address.string);
+        const circularDependencyCellAddresses = [];
+        const resolvedDependencyHashes = [];
+        const unresolvedDependencyCellAddresses = [];
+        for (const dependencyCellAddress of this.dependencyCellAddresses.orDefault([])) {
+            if (visitedCellAddresses.has(dependencyCellAddress.string)) {
+                circularDependencyCellAddresses.push(dependencyCellAddress.string);
+                continue;
+            }
+            this.worksheet.workbook
+                .cell(dependencyCellAddress)
+                .ifJust((dependency) => {
+                if (dependency.formula.isJust()) {
+                    resolvedDependencyHashes.push(dependency.hashRecursive(visitedCellAddresses));
+                }
+                else {
+                    resolvedDependencyHashes.push(dependency.sha256);
+                }
+            })
+                .ifNothing(() => {
+                unresolvedDependencyCellAddresses.push(dependencyCellAddress.string);
+            });
+        }
+        visitedCellAddresses.delete(this.address.string);
+        this.#sha256 = sha256(JSON.stringify({
+            address: this.address.toJSON(),
+            circularDependencyCellAddresses: circularDependencyCellAddresses.length > 0
+                ? circularDependencyCellAddresses
+                : undefined,
+            formula: this.formula.extract(),
+            hyperlink: this.hyperlink.map(Cell.Hyperlink.toJSON).extract(),
+            resolvedDependencyHashes: resolvedDependencyHashes.length > 0
+                ? resolvedDependencyHashes
+                : undefined,
+            unresolvedDependencyCellAddresses: unresolvedDependencyCellAddresses.length > 0
+                ? unresolvedDependencyCellAddresses
+                : undefined,
+            value: this.value.map(Cell.Value.toJSON).extract(),
+        }));
+        return this.#sha256;
+    }
+}
+__decorate([
+    Memoize()
+], Cell.prototype, "dependencies", null);
+__decorate([
+    Memoize()
+], Cell.prototype, "dependencyCellAddresses", null);
+(function (Cell) {
+    // biome-ignore lint/suspicious/noShadowRestrictedNames: Only used here
+    class Error {
+        value;
+        constructor(value) {
+            this.value = value;
+        }
+    }
+    Cell.Error = Error;
+    let Hyperlink;
+    (function (Hyperlink) {
+        function toJSON(hyperlink) {
+            return { target: hyperlink.target, tooltip: hyperlink.tooltip.extract() };
+        }
+        Hyperlink.toJSON = toJSON;
+    })(Hyperlink = Cell.Hyperlink || (Cell.Hyperlink = {}));
+    let Value;
+    (function (Value) {
+        function toJSON(value) {
+            switch (typeof value) {
+                case "boolean":
+                case "number":
+                case "string":
+                    return value;
+                case "object":
+                    if (value instanceof Date) {
+                        return value.toISOString();
+                    }
+                    else if (value instanceof Cell.Error) {
+                        return {
+                            error: value.value,
+                        };
+                    }
+                    else {
+                        value;
+                        throw new RangeError();
+                    }
+                default:
+                    value;
+                    throw new RangeError(typeof value);
+            }
+        }
+        Value.toJSON = toJSON;
+    })(Value = Cell.Value || (Cell.Value = {}));
+})(Cell || (Cell = {}));
+//# sourceMappingURL=Cell.js.map

package/dist/CellAddress.d.ts

@@ -0,0 +1,28 @@
+/**
+ * A cell address qualified with the worksheet name. Can be serialized with the .string method to "Sheet!A1".
+ */
+export declare class CellAddress {
+    /**
+     * Zero-based column index.
+     **/
+    readonly columnIndex: number;
+    /**
+     * Zero-based row index
+     */
+    readonly rowIndex: number;
+    /**
+     * Worksheet name.
+     */
+    readonly worksheetName: string;
+    constructor({ columnIndex, rowIndex, worksheetName, }: {
+        columnIndex: number;
+        rowIndex: number;
+        worksheetName: string;
+    });
+    get columnLetter(): string;
+    get string(): string;
+    static parse(cellAddress: string, worksheetName: string): CellAddress;
+    toJSON(): string;
+    toString(): string;
+}
+//# sourceMappingURL=CellAddress.d.ts.map

package/dist/CellAddress.js

@@ -0,0 +1,77 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { invariant } from "ts-invariant";
+import { Memoize } from "typescript-memoize";
+import * as xlsx from "xlsx";
+/**
+ * A cell address qualified with the worksheet name. Can be serialized with the .string method to "Sheet!A1".
+ */
+export class CellAddress {
+    /**
+     * Zero-based column index.
+     **/
+    columnIndex;
+    /**
+     * Zero-based row index
+     */
+    rowIndex;
+    /**
+     * Worksheet name.
+     */
+    worksheetName;
+    constructor({ columnIndex, rowIndex, worksheetName, }) {
+        invariant(Number.isInteger(columnIndex) && columnIndex >= 0, columnIndex);
+        invariant(Number.isInteger(rowIndex) && rowIndex >= 0, rowIndex);
+        this.columnIndex = columnIndex;
+        this.rowIndex = rowIndex;
+        // Strip quotes off the worksheet name
+        if (worksheetName.length >= 2 &&
+            worksheetName.startsWith("'") &&
+            worksheetName.endsWith("'")) {
+            // unescape double single-quotes -> single quote
+            worksheetName = worksheetName.slice(1, -1).replace(/''/g, "'");
+        }
+        this.worksheetName = worksheetName;
+    }
+    get columnLetter() {
+        let letter = "";
+        let n = this.columnIndex + 1;
+        while (n > 0) {
+            letter = String.fromCharCode(((n - 1) % 26) + 65) + letter;
+            n = Math.floor((n - 1) / 26);
+        }
+        return letter;
+    }
+    get string() {
+        const quotedSheetName = /[^A-Za-z0-9_]/.test(this.worksheetName)
+            ? // escape single quotes by doubling them
+                `'${this.worksheetName.replace(/'/g, "''")}'`
+            : this.worksheetName;
+        return `${quotedSheetName}!${this.columnLetter}${this.rowIndex + 1}`;
+    }
+    static parse(cellAddress, worksheetName) {
+        const decodedCellAddress = xlsx.utils.decode_cell(cellAddress); // { r: 0, c: 0 } (0-based)
+        return new CellAddress({
+            columnIndex: decodedCellAddress.c,
+            rowIndex: decodedCellAddress.r,
+            worksheetName: worksheetName,
+        });
+    }
+    toJSON() {
+        return this.toString();
+    }
+    toString() {
+        return this.string;
+    }
+}
+__decorate([
+    Memoize()
+], CellAddress.prototype, "columnLetter", null);
+__decorate([
+    Memoize()
+], CellAddress.prototype, "string", null);
+//# sourceMappingURL=CellAddress.js.map

package/dist/JsonResourceRecordParser.d.ts

@@ -0,0 +1,32 @@
+import type { NamespaceBuilder } from "@rdfjs/namespace";
+import type PrefixMap from "@rdfjs/prefix-map/PrefixMap.js";
+import type { Quad } from "@rdfjs/types";
+import { type Resource, ResourceSet } from "@rdfx/resource";
+import type { Either } from "purify-ts";
+import { AbstractParser } from "./AbstractParser.js";
+import type { ResourceRecord } from "./ResourceRecord.js";
+import type { ResourceRecordParser } from "./ResourceRecordParser.js";
+interface IntermediateObjectFunctions<IntermediateObjectT extends object, JsonObjectT extends object> {
+    Json: {
+        parse(json: unknown): Either<Error, JsonObjectT>;
+    };
+    fromJson: (jsonObject: JsonObjectT, options?: {
+        defaultNamespace?: NamespaceBuilder;
+        prefixMap?: PrefixMap;
+    }) => Either<Error, IntermediateObjectT>;
+    toRdfResource: (object: IntermediateObjectT, options?: {
+        resourceSet?: ResourceSet;
+    }) => Resource;
+}
+export declare class JsonResourceRecordParser<IntermediateObjectT extends object, JsonObjectT extends object> extends AbstractParser implements ResourceRecordParser {
+    private readonly intermediateObjectFunctions;
+    constructor(intermediateObjectFunctions: IntermediateObjectFunctions<IntermediateObjectT, JsonObjectT>, superParameters: ConstructorParameters<typeof AbstractParser>[0]);
+    /**
+     * Parse a ResourceRecord into an array of RDF Quads.
+     *
+     * Takes dataFactory, et al. parameters here rather than in the constructor in order to simplify construction.
+     */
+    parse(resourceRecord: ResourceRecord): Either<Error, readonly Quad[]>;
+}
+export {};
+//# sourceMappingURL=JsonResourceRecordParser.d.ts.map

package/dist/JsonResourceRecordParser.js

@@ -0,0 +1,30 @@
+import { ResourceSet } from "@rdfx/resource";
+import { AbstractParser } from "./AbstractParser.js";
+export class JsonResourceRecordParser extends AbstractParser {
+    intermediateObjectFunctions;
+    constructor(intermediateObjectFunctions, superParameters) {
+        super(superParameters);
+        this.intermediateObjectFunctions = intermediateObjectFunctions;
+    }
+    /**
+     * Parse a ResourceRecord into an array of RDF Quads.
+     *
+     * Takes dataFactory, et al. parameters here rather than in the constructor in order to simplify construction.
+     */
+    parse(resourceRecord) {
+        return this.intermediateObjectFunctions.Json.parse(resourceRecord).chain((jsonObject) => this.intermediateObjectFunctions
+            .fromJson(jsonObject, {
+            defaultNamespace: this.defaultNamespace.extract(),
+            prefixMap: this.prefixMap.extract(),
+        })
+            .map((object) => [
+            ...this.intermediateObjectFunctions.toRdfResource(object, {
+                resourceSet: new ResourceSet({
+                    dataFactory: this.dataFactory,
+                    dataset: this.datasetFactory.dataset(),
+                }),
+            }).dataset,
+        ]));
+    }
+}
+//# sourceMappingURL=JsonResourceRecordParser.js.map

package/dist/LangString.d.ts

@@ -0,0 +1,9 @@
+export declare class LangString {
+    readonly "@language": string;
+    readonly "@value": string;
+    constructor({ language, value }: {
+        language: string;
+        value: string;
+    });
+}
+//# sourceMappingURL=LangString.d.ts.map

package/dist/LangString.js

@@ -0,0 +1,9 @@
+export class LangString {
+    "@language";
+    "@value";
+    constructor({ language, value }) {
+        this["@language"] = language;
+        this["@value"] = value;
+    }
+}
+//# sourceMappingURL=LangString.js.map

package/dist/ResourceRecord.d.ts

@@ -0,0 +1,6 @@
+import type { LangString } from "./LangString.js";
+export type ResourceRecord = Record<string, ResourceRecord.Value | ResourceRecord.Value[]>;
+export declare namespace ResourceRecord {
+    type Value = boolean | Date | LangString | number | string;
+}
+//# sourceMappingURL=ResourceRecord.d.ts.map

package/dist/ResourceRecord.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ResourceRecord.js.map

package/dist/ResourceRecordParser.d.ts

@@ -0,0 +1,12 @@
+import type { Quad } from "@rdfjs/types";
+import type { Either } from "purify-ts";
+import type { ResourceRecord } from "./ResourceRecord.js";
+export interface ResourceRecordParser {
+    /**
+     * Parse a ResourceRecord into an array of RDF Quads.
+     *
+     * Receives dataFactory and other parameters here so they don't have to be passed to constructors.
+     */
+    parse(resourceRecord: ResourceRecord): Either<Error, readonly Quad[]>;
+}
+//# sourceMappingURL=ResourceRecordParser.d.ts.map

package/dist/ResourceRecordParser.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ResourceRecordParser.js.map

package/dist/ResourceRecordParserFactory.d.ts

@@ -0,0 +1,4 @@
+import type { AbstractParser } from "./AbstractParser.js";
+import type { ResourceRecordParser } from "./ResourceRecordParser.js";
+export type ResourceRecordParserFactory = (parameters: ConstructorParameters<typeof AbstractParser>[0]) => ResourceRecordParser;
+//# sourceMappingURL=ResourceRecordParserFactory.d.ts.map

package/dist/ResourceRecordParserFactory.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ResourceRecordParserFactory.js.map

package/dist/ResourceWorkbookParser.d.ts

@@ -0,0 +1,14 @@
+import type { Quad } from "@rdfjs/types";
+import { Either } from "purify-ts";
+import { AbstractParser } from "./AbstractParser.js";
+import type { ResourceRecordParser } from "./ResourceRecordParser.js";
+import type { ResourceRecordParserFactory } from "./ResourceRecordParserFactory.js";
+import type { Workbook } from "./Workbook.js";
+export declare class ResourceWorkbookParser extends AbstractParser {
+    private readonly resourceRecordParsersByWorksheetName;
+    constructor({ resourceRecordParsersByWorksheetName, ...superParameters }: {
+        resourceRecordParsersByWorksheetName: Readonly<Record<string, ResourceRecordParser | ResourceRecordParserFactory>>;
+    } & ConstructorParameters<typeof AbstractParser>[0]);
+    parse(workbook: Workbook): Either<Error, readonly Quad[]>;
+}
+//# sourceMappingURL=ResourceWorkbookParser.d.ts.map

package/dist/ResourceWorkbookParser.js

@@ -0,0 +1,37 @@
+import { Either } from "purify-ts";
+import { AbstractParser } from "./AbstractParser.js";
+import { ResourceWorksheetParser } from "./ResourceWorksheetParser.js";
+export class ResourceWorkbookParser extends AbstractParser {
+    resourceRecordParsersByWorksheetName;
+    constructor({ resourceRecordParsersByWorksheetName, ...superParameters }) {
+        super(superParameters);
+        this.resourceRecordParsersByWorksheetName =
+            resourceRecordParsersByWorksheetName;
+    }
+    parse(workbook) {
+        let workbookQuads = [];
+        for (const worksheet of workbook.worksheets) {
+            const resourceRecordParser = this.resourceRecordParsersByWorksheetName[worksheet.name];
+            if (resourceRecordParser === undefined) {
+                this.logger.debug({ worksheet: { name: worksheet.name } }, "no resource row parser for worksheet");
+                continue;
+            }
+            const worksheetDatasetEither = new ResourceWorksheetParser({
+                dataFactory: this.dataFactory,
+                datasetFactory: this.datasetFactory,
+                defaultNamespace: this.defaultNamespace,
+                logger: this.logger,
+                prefixMap: this.prefixMap,
+                resourceRecordParser,
+            }).parse(worksheet);
+            if (worksheetDatasetEither.isLeft()) {
+                return worksheetDatasetEither;
+            }
+            worksheetDatasetEither.ifRight((worksheetQuads) => {
+                workbookQuads = workbookQuads.concat(worksheetQuads);
+            });
+        }
+        return Either.of(workbookQuads);
+    }
+}
+//# sourceMappingURL=ResourceWorkbookParser.js.map

package/dist/ResourceWorksheetParser.d.ts

@@ -0,0 +1,15 @@
+import type { Quad } from "@rdfjs/types";
+import { Either } from "purify-ts";
+import { AbstractParser } from "./AbstractParser.js";
+import type { ResourceRecordParser } from "./ResourceRecordParser.js";
+import type { ResourceRecordParserFactory } from "./ResourceRecordParserFactory.js";
+import type { Worksheet } from "./Worksheet.js";
+export declare class ResourceWorksheetParser extends AbstractParser {
+    private readonly resourceRecordParser;
+    constructor({ resourceRecordParser, ...superParameters }: {
+        resourceRecordParser: ResourceRecordParser | ResourceRecordParserFactory;
+    } & ConstructorParameters<typeof AbstractParser>[0]);
+    parse(worksheet: Worksheet): Either<Error, readonly Quad[]>;
+    private parseHeaderRow;
+}
+//# sourceMappingURL=ResourceWorksheetParser.d.ts.map

package/dist/ResourceWorksheetParser.js

@@ -0,0 +1,136 @@
+import { Either, Left, Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
+import { AbstractParser } from "./AbstractParser.js";
+import { Cell } from "./Cell.js";
+import { LangString } from "./LangString.js";
+export class ResourceWorksheetParser extends AbstractParser {
+    resourceRecordParser;
+    constructor({ resourceRecordParser, ...superParameters }) {
+        super(superParameters);
+        this.resourceRecordParser = resourceRecordParser;
+    }
+    parse(worksheet) {
+        let headerRow;
+        const resourceRecordParser = typeof this.resourceRecordParser === "function"
+            ? this.resourceRecordParser({
+                dataFactory: this.dataFactory,
+                datasetFactory: this.datasetFactory,
+                defaultNamespace: this.defaultNamespace,
+                logger: this.logger,
+                prefixMap: this.prefixMap,
+            })
+            : this.resourceRecordParser;
+        let worksheetQuads = [];
+        for (const [worksheetRowI, worksheetRow] of worksheet.rows.entries()) {
+            if (worksheetRowI === 0) {
+                const headerRowEither = this.parseHeaderRow(worksheet, worksheetRow);
+                if (headerRowEither.isLeft()) {
+                    return headerRowEither.mapLeft((error) => new Error(`${worksheet.name}: ${error.message}`));
+                }
+                headerRow = headerRowEither.extract();
+                continue;
+            }
+            invariant(headerRow);
+            const resourceRecord = {};
+            for (const [worksheetColumnI, worksheetCell] of worksheetRow.entries()) {
+                const logContext = {
+                    worksheet: {
+                        column: worksheetColumnI,
+                        name: worksheet.name,
+                        row: worksheetRowI,
+                    },
+                };
+                if (worksheetColumnI >= headerRow.length) {
+                    this.logger.warn(logContext, "more columns than header row");
+                    continue;
+                }
+                const columnMetadata = headerRow[worksheetColumnI];
+                if (worksheetCell === undefined) {
+                    this.logger.debug(logContext, "undefined cell");
+                    continue;
+                }
+                let newValue;
+                if (worksheetCell.hyperlink.isJust()) {
+                    newValue = worksheetCell.hyperlink.extract().target;
+                }
+                else {
+                    const worksheetCellValue = worksheetCell.value.extract();
+                    if (worksheetCellValue === undefined) {
+                        this.logger.debug(logContext, "cell without value");
+                        continue;
+                    }
+                    if (worksheetCellValue instanceof Cell.Error) {
+                        this.logger.debug(logContext, "error cell");
+                        continue;
+                    }
+                    newValue = worksheetCellValue;
+                }
+                if (columnMetadata.language.isJust()) {
+                    newValue = new LangString({
+                        language: columnMetadata.language.extract(),
+                        value: newValue instanceof Date
+                            ? newValue.toISOString()
+                            : newValue.toString(),
+                    });
+                }
+                const existingValue = resourceRecord[columnMetadata.property];
+                if (existingValue === undefined) {
+                    resourceRecord[columnMetadata.property] = newValue;
+                }
+                else if (Array.isArray(existingValue)) {
+                    existingValue.push(newValue);
+                }
+                else {
+                    resourceRecord[columnMetadata.property] = [existingValue, newValue];
+                }
+            }
+            const rowQuadsEither = resourceRecordParser.parse(resourceRecord);
+            if (rowQuadsEither.isLeft()) {
+                return rowQuadsEither;
+            }
+            rowQuadsEither.ifRight((rowQuads) => {
+                worksheetQuads = worksheetQuads.concat(rowQuads);
+            });
+        }
+        return Either.of(worksheetQuads);
+    }
+    parseHeaderRow(worksheet, row) {
+        const parsed = [];
+        for (const [columnI, cell] of row.entries()) {
+            if (cell === undefined) {
+                return Left(new Error(`worksheet ${worksheet.name} header row column ${columnI} is empty`));
+            }
+            const cellValue = cell.value.extract();
+            if (cellValue === undefined) {
+                return Left(new Error(`header cell ${cell.address} has no value`));
+            }
+            if (typeof cellValue !== "string") {
+                return Left(new Error(`header cell ${cell.address} has non-string value`));
+            }
+            let property;
+            let language;
+            if (cellValue.startsWith("@")) {
+                property = cellValue;
+            }
+            else {
+                [property, language] = cellValue.split("@", 2);
+            }
+            property = property.trim();
+            if (property.length === 0) {
+                return Left(new Error(`header cell ${cell.address} doesn't specify a property: ${cellValue}`));
+            }
+            if (language) {
+                language = language.trim();
+                if (language.length === 0) {
+                    return Left(new Error(`empty language in header cell ${cell.address}: ${cellValue}`));
+                }
+            }
+            parsed.push({
+                language: Maybe.fromNullable(language),
+                property,
+            });
+        }
+        return Either.of(parsed);
+    }
+}
+//# sourceMappingURL=ResourceWorksheetParser.js.map

package/dist/Workbook.d.ts

@@ -0,0 +1,23 @@
+import { type Logger } from "@rdfx/logger";
+import { Either, Maybe } from "purify-ts";
+import type { Cell } from "./Cell.js";
+import type { CellAddress } from "./CellAddress.js";
+import { Worksheet } from "./Worksheet.js";
+export declare class Workbook {
+    private readonly delegate;
+    private readonly depParser;
+    private readonly logger;
+    private constructor();
+    get cells(): readonly Cell[];
+    get cellsByAddress(): ReadonlyMap<string, Cell>;
+    /**
+     * SHA-256 sha256 hex digest of this workbook.
+     */
+    get sha256(): string;
+    get worksheets(): readonly Worksheet[];
+    static read(data: Uint8Array, options?: {
+        logger?: Logger;
+    }): Either<Error, Workbook>;
+    cell(address: CellAddress): Maybe<Cell>;
+}
+//# sourceMappingURL=Workbook.d.ts.map

package/dist/Workbook.js

@@ -0,0 +1,88 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { nopLogger } from "@rdfx/logger";
+import { DepParser } from "fast-formula-parser";
+import { sha256 } from "js-sha256";
+import { Either, Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
+import { Memoize } from "typescript-memoize";
+import * as xlsx from "xlsx";
+import { Worksheet } from "./Worksheet.js";
+export class Workbook {
+    delegate;
+    depParser = new DepParser();
+    logger;
+    constructor({ delegate, logger, }) {
+        this.delegate = delegate;
+        this.logger = logger;
+    }
+    get cells() {
+        return [...this.cellsByAddress.values()];
+    }
+    get cellsByAddress() {
+        const cellsByAddress = new Map();
+        for (const worksheet of this.worksheets) {
+            for (const cell of worksheet.cells) {
+                invariant(!cellsByAddress.has(cell.address.string), cell.address.string);
+                cellsByAddress.set(cell.address.string, cell);
+            }
+        }
+        return cellsByAddress;
+    }
+    /**
+     * SHA-256 sha256 hex digest of this workbook.
+     */
+    get sha256() {
+        const hasher = sha256.create();
+        for (const worksheet of this.worksheets) {
+            hasher.update(worksheet.sha256);
+        }
+        return hasher.hex();
+    }
+    get worksheets() {
+        return Object.entries(this.delegate.Sheets).map(([name, worksheet], index) => new Worksheet({
+            definedNames: this.delegate.Workbook?.Names ?? [],
+            delegate: worksheet,
+            depParser: this.depParser,
+            hidden: (this.delegate.Workbook?.Sheets?.[index]?.Hidden ?? 0) !== 0,
+            index,
+            logger: this.logger,
+            name,
+            workbook: this,
+        }));
+    }
+    static read(data, options) {
+        return Either.encase(() => {
+            return new Workbook({
+                delegate: xlsx.read(data, {
+                    cellFormula: true,
+                    cellNF: true,
+                    cellDates: true,
+                    sheetStubs: true,
+                    WTF: true,
+                }),
+                logger: options?.logger ?? nopLogger,
+            });
+        });
+    }
+    cell(address) {
+        return Maybe.fromNullable(this.cellsByAddress.get(address.string));
+    }
+}
+__decorate([
+    Memoize()
+], Workbook.prototype, "cells", null);
+__decorate([
+    Memoize()
+], Workbook.prototype, "cellsByAddress", null);
+__decorate([
+    Memoize()
+], Workbook.prototype, "sha256", null);
+__decorate([
+    Memoize()
+], Workbook.prototype, "worksheets", null);
+//# sourceMappingURL=Workbook.js.map

package/dist/Worksheet.d.ts

@@ -0,0 +1,60 @@
+import type { Logger } from "@rdfx/logger";
+import type { DepParser } from "fast-formula-parser";
+import { Maybe } from "purify-ts";
+import * as xlsx from "xlsx";
+import { Cell } from "./Cell.js";
+import { CellAddress } from "./CellAddress.js";
+import type { Workbook } from "./Workbook.js";
+export declare class Worksheet {
+    #private;
+    private readonly delegate;
+    private readonly depParser;
+    private readonly index;
+    private readonly logger;
+    readonly hidden: boolean;
+    readonly name: string;
+    readonly workbook: Workbook;
+    constructor({ definedNames, delegate, depParser, hidden, index, logger, name, workbook, }: {
+        definedNames: readonly xlsx.DefinedName[];
+        delegate: xlsx.WorkSheet;
+        depParser: DepParser;
+        hidden: boolean;
+        index: number;
+        logger: Logger;
+        name: string;
+        workbook: Workbook;
+    });
+    /**
+     * Array of all cells.
+     */
+    get cells(): readonly Cell[];
+    /**
+     * Sparse map of cell address strings (qualified with sheet name: "Sheet!A1") to cells,
+     * mirroring the way .xlsx stores cells natively.
+     */
+    get cellsByAddress(): ReadonlyMap<string, Cell>;
+    /**
+     * Get defined names from the perspective of this worksheet.
+     *
+     * The result will include:
+     * - worksheet-local names
+     * - workbook-global names that aren't overridden by a worksheet-local name
+     */
+    get definedNames(): readonly [CellAddress, string][];
+    /**
+     * Dense array of rows with undefined's for empty cells.
+     *
+     * Includes any row that has a populated cell (i.e., within the !ref range of the worksheet).
+     */
+    get rows(): readonly Worksheet.Row[];
+    /**
+     * SHA-256 sha256 hex digest of this worksheet.
+     */
+    get sha256(): string;
+    cell(address: CellAddress | string): Maybe<Cell>;
+    toString(): string;
+}
+export declare namespace Worksheet {
+    type Row = readonly (Cell | undefined)[];
+}
+//# sourceMappingURL=Worksheet.d.ts.map

package/dist/Worksheet.js

@@ -0,0 +1,196 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { sha256 } from "js-sha256";
+import { Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
+import { Memoize } from "typescript-memoize";
+import * as xlsx from "xlsx";
+import { Cell } from "./Cell.js";
+import { CellAddress } from "./CellAddress.js";
+export class Worksheet {
+    #definedNames;
+    delegate;
+    depParser;
+    index;
+    logger;
+    hidden;
+    name;
+    workbook;
+    constructor({ definedNames, delegate, depParser, hidden, index, logger, name, workbook, }) {
+        this.#definedNames = definedNames;
+        this.delegate = delegate;
+        this.depParser = depParser;
+        this.hidden = hidden;
+        this.index = index;
+        this.logger = logger;
+        this.name = name;
+        this.workbook = workbook;
+    }
+    /**
+     * Array of all cells.
+     */
+    get cells() {
+        return [...this.cellsByAddress.values()];
+    }
+    /**
+     * Sparse map of cell address strings (qualified with sheet name: "Sheet!A1") to cells,
+     * mirroring the way .xlsx stores cells natively.
+     */
+    get cellsByAddress() {
+        const cellsByAddress = new Map();
+        for (const [cellAddressString, cellAny] of Object.entries(this.delegate)) {
+            // SheetJS uses keys like '!ref', '!margins' etc for metadata
+            if (cellAddressString.startsWith("!")) {
+                continue;
+            }
+            const cellObject = cellAny;
+            const cellAddress = CellAddress.parse(cellAddressString, this.name);
+            const hyperlink = cellObject.l
+                ? Maybe.of({
+                    target: cellObject.l.Target,
+                    tooltip: Maybe.fromNullable(cellObject.l.Tooltip),
+                })
+                : Maybe.empty();
+            let value;
+            switch (cellObject.t) {
+                case "b": // Boolean
+                case "d": // Date
+                case "n": // Number
+                case "s": // String
+                    value = Maybe.fromNullable(cellObject.v);
+                    break;
+                case "e": // Error
+                    invariant(cellObject.w);
+                    value = Maybe.of(new Cell.Error(cellObject.w));
+                    break;
+                case "z": // Empty
+                    value = Maybe.empty();
+                    break;
+                default:
+                    throw new RangeError(`${cellAddress}: unexpected cell object type: ${cellObject.t}`);
+            }
+            let formula;
+            if (cellObject.f === "undefined") {
+                formula = Maybe.empty();
+                value = Maybe.of(new Cell.Error("unparseable formula or macro"));
+            }
+            else {
+                formula = Maybe.fromNullable(cellObject.f);
+            }
+            const cell = new Cell({
+                address: cellAddress,
+                depParser: this.depParser,
+                hyperlink,
+                formula,
+                value,
+                worksheet: this,
+            });
+            invariant(!cellsByAddress.has(cell.address.string), cell.address.string);
+            cellsByAddress.set(cell.address.string, cell);
+        }
+        return cellsByAddress;
+    }
+    /**
+     * Get defined names from the perspective of this worksheet.
+     *
+     * The result will include:
+     * - worksheet-local names
+     * - workbook-global names that aren't overridden by a worksheet-local name
+     */
+    get definedNames() {
+        const result = new Map();
+        for (const scope of ["worksheet", "workbook"]) {
+            for (const definedName of this.#definedNames) {
+                if ((scope === "worksheet" && definedName.Sheet === this.index) ||
+                    (scope === "workbook" && typeof definedName.Sheet === "undefined")) {
+                    const refMatch = definedName.Ref.match(/^(?:'([^']+)'|([^!]+))!\$?([A-Z]+)\$?(\d+)$/);
+                    if (!refMatch) {
+                        continue; // Ref is not to a single cell
+                    }
+                    const refWorksheetName = refMatch[1] || refMatch[2];
+                    const refCol = refMatch[3];
+                    const refRow = refMatch[4];
+                    const refDecodedCell = xlsx.utils.decode_cell(`${refCol}${refRow}`); // { r: 0, c: 0 } (0-based)
+                    const refCellAddress = new CellAddress({
+                        columnIndex: refDecodedCell.c,
+                        rowIndex: refDecodedCell.r,
+                        worksheetName: refWorksheetName ?? this.name,
+                    });
+                    if (scope === "worksheet") {
+                        if (result.has(definedName.Name)) {
+                            this.logger.warn("duplicate worksheet-local defined name %s for cell %s", definedName.Name, refCellAddress);
+                            continue;
+                        }
+                    }
+                    else {
+                        if (result.has(definedName.Name)) {
+                            this.logger.debug("workbook-global name %s overridden by worksheet-local name", definedName.Name);
+                            continue;
+                        }
+                    }
+                    result.set(definedName.Name, [refCellAddress, definedName.Name]);
+                }
+            }
+        }
+        return [...result.values()];
+    }
+    /**
+     * Dense array of rows with undefined's for empty cells.
+     *
+     * Includes any row that has a populated cell (i.e., within the !ref range of the worksheet).
+     */
+    get rows() {
+        const worksheetRange = xlsx.utils.decode_range(this.delegate["!ref"] || "A1");
+        const rows = [];
+        for (let r = worksheetRange.s.r; r <= worksheetRange.e.r; ++r) {
+            const row = [];
+            for (let c = worksheetRange.s.c; c <= worksheetRange.e.c; ++c) {
+                row.push(this.cellsByAddress.get(CellAddress.parse(xlsx.utils.encode_cell({ c, r }), this.name)
+                    .string));
+            }
+            rows.push(row);
+        }
+        return rows;
+    }
+    /**
+     * SHA-256 sha256 hex digest of this worksheet.
+     */
+    get sha256() {
+        const hasher = sha256.create();
+        for (const cell of this.cells) {
+            hasher.update(cell.sha256);
+        }
+        return hasher.hex();
+    }
+    cell(address) {
+        return Maybe.fromNullable(this.cellsByAddress.get(typeof address === "object"
+            ? address.string
+            : CellAddress.parse(address, this.name).string));
+    }
+    toString() {
+        return `Worksheet(name=${this.name})`;
+    }
+}
+__decorate([
+    Memoize()
+], Worksheet.prototype, "cells", null);
+__decorate([
+    Memoize()
+], Worksheet.prototype, "cellsByAddress", null);
+__decorate([
+    Memoize()
+], Worksheet.prototype, "definedNames", null);
+__decorate([
+    Memoize()
+], Worksheet.prototype, "rows", null);
+__decorate([
+    Memoize()
+], Worksheet.prototype, "sha256", null);
+__decorate([
+    Memoize()
+], Worksheet.prototype, "toString", null);
+//# sourceMappingURL=Worksheet.js.map

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./Cell.js";
+export * from "./CellAddress.js";
+export * from "./Workbook.js";
+export * from "./Worksheet.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from "./Cell.js";
+export * from "./CellAddress.js";
+export * from "./Workbook.js";
+export * from "./Worksheet.js";
+//# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,49 @@
 {
+  "dependencies": {
+    "@rdfx/logger": "0.0.60",
+    "@rdfx/resource": "0.0.60",
+    "@rdfjs/namespace": "~2.0.1",
+    "@rdfjs/prefix-map": "~0.1.2",
+    "@rdfjs/types": "~2.0.1",
+    "@types/rdfjs__namespace": "~2.0.10",
+    "@types/rdfjs__prefix-map": "~0.1.5",
+    "fast-formula-parser": "1.0.19",
+    "js-sha256": "~0.11.1",
+    "purify-ts": "~2.1.4",
+    "ts-invariant": "~0.10.3",
+    "typescript-memoize": "~1.1.1",
+    "xlsx": "https://cdn.sheetjs.com/xlsx-0.20.3/xlsx-0.20.3.tgz"
+  },
+  "devDependencies": {
+    "@rdfx/collection": "0.0.60",
+    "@rdfx/testing": "0.0.60",
+    "@shaclmate/cli": "4.0.100",
+    "@types/node": "^24",
+    "libreoffice-convert": "~1.8.1",
+    "zod": "~4.1.12"
+  },
+  "files": [
+    "LICENSE",
+    "dist/*.d.ts",
+    "dist/*.js"
+  ],
+  "license": "Apache-2.0",
+  "main": "./dist/index.js",
   "name": "@rdfx/xlsx",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "packageManager": "npm@11.11.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/minorg/rdfx.git"
+  },
+  "scripts": {
+    "build": "tsc -b",
+    "clean": "rimraf dist",
+    "depcheck": "depcheck --ignores=\"@tsconfig/*,vitest,vitest-fetch-mock\" .",
+    "dev": "tsc -w --preserveWatchOutput",
+    "dev:tests": "tsc -p __tests__ -w --preserveWatchOutput",
+    "test": "cd ../.. && vitest run packages/xlsx/__tests__"
+  },
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "version": "0.0.60"
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.