@qvac/harness 0.7.2 → 0.8.0

package/dist-lib/lib/office/engine/xlsx/formula.d.ts

@@ -0,0 +1,49 @@
+export type RefKind = 'cell' | 'range' | 'columns' | 'rows';
+export interface Point {
+    col?: number;
+    row?: number;
+    absCol?: boolean;
+    absRow?: boolean;
+}
+export interface Ref {
+    kind: RefKind;
+    start: Point;
+    end: Point | null;
+    length: number;
+}
+export interface Change {
+    sheet: string;
+    axis: 'row' | 'col';
+    at: number;
+    count: number;
+    kind: 'insert' | 'delete';
+}
+export interface RefContext {
+    sheet: string | null;
+    original: string;
+}
+export interface Handlers {
+    onRef?: (ref: Ref, context: RefContext) => string | null;
+    onSheet?: (names: string[], text: string) => string;
+    onTable?: (name: string) => void;
+}
+export interface Rename {
+    from: string;
+    to: string;
+}
+export interface Offset {
+    rows: number;
+    cols: number;
+}
+export declare function scan(formula: string, handlers?: Handlers): string;
+export declare function sheetsIn(formula: string): string[];
+export declare function tablesIn(formula: string): string[];
+export declare function usesTable(formula: string, table: string): boolean;
+export declare function mentions(formula: string, sheet: string): boolean;
+export declare function renameSheet(formula: string, rename: Rename): string;
+export declare function shift(formula: string, offset: Offset): string;
+export declare function moveIndex(i: number, change: Change): number | null;
+export declare function moveSpan(span: [number, number], change: Change): [number, number] | null;
+export declare function adjust(formula: string, ownSheet: string | null, change: Change): string;
+export declare function references(formula: string, ownSheet: string | null, sheet: string): boolean;
+export declare function adjustRange(range: string, change: Change): string | null;

package/dist-lib/lib/office/engine/xlsx/formula.js

@@ -0,0 +1,381 @@
+import * as refs from './refs.js';
+const NAME_START = /[A-Za-z_À-￿]/;
+const WORD = /[A-Za-z0-9_.À-￿]/;
+const BARE_PREFIX = /[A-Za-z_À-￿][\w.À-￿]*(?::[A-Za-z_À-￿][\w.À-￿]*)?!/y;
+const CELL_RANGE = /(\$?)([A-Za-z]{1,3})(\$?)(\d{1,7})(?::(\$?)([A-Za-z]{1,3})(\$?)(\d{1,7}))?(?![A-Za-z0-9_(![])/y;
+const COLUMN_RANGE = /(\$?)([A-Za-z]{1,3}):(\$?)([A-Za-z]{1,3})(?![A-Za-z0-9_(![])/y;
+const ROW_RANGE = /(\$?)(\d{1,7}):(\$?)(\d{1,7})(?![A-Za-z0-9_(.![])/y;
+const WORKBOOK = /\[[^\]]*\]/;
+function quoted(text, at, quote) {
+    let i = at + 1;
+    while (i < text.length) {
+        if (text[i] === quote && text[i + 1] === quote) {
+            i += 2;
+        }
+        else if (text[i] === quote) {
+            return i + 1;
+        }
+        else {
+            i++;
+        }
+    }
+    return text.length;
+}
+function matchAt(re, text, at) {
+    re.lastIndex = at;
+    return re.exec(text);
+}
+function inColumns(letters) {
+    return letters === undefined || refs.columnIndex(letters) < refs.MAX_COLUMNS;
+}
+function cellRef(m) {
+    const start = {
+        col: refs.columnIndex(m[2]),
+        row: Number(m[4]) - 1,
+        absCol: m[1] === '$',
+        absRow: m[3] === '$'
+    };
+    const end = m[6]
+        ? {
+            col: refs.columnIndex(m[6]),
+            row: Number(m[8]) - 1,
+            absCol: m[5] === '$',
+            absRow: m[7] === '$'
+        }
+        : null;
+    return { kind: end ? 'range' : 'cell', start, end, length: m[0].length };
+}
+function readRef(text, at) {
+    const cells = matchAt(CELL_RANGE, text, at);
+    if (cells && inColumns(cells[2]) && inColumns(cells[6])) {
+        return cellRef(cells);
+    }
+    const columns = matchAt(COLUMN_RANGE, text, at);
+    if (columns && inColumns(columns[2]) && inColumns(columns[4])) {
+        return {
+            kind: 'columns',
+            start: { col: refs.columnIndex(columns[2]), absCol: columns[1] === '$' },
+            end: { col: refs.columnIndex(columns[4]), absCol: columns[3] === '$' },
+            length: columns[0].length
+        };
+    }
+    const rows = matchAt(ROW_RANGE, text, at);
+    if (!rows) {
+        return null;
+    }
+    return {
+        kind: 'rows',
+        start: { row: Number(rows[2]) - 1, absRow: rows[1] === '$' },
+        end: { row: Number(rows[4]) - 1, absRow: rows[3] === '$' },
+        length: rows[0].length
+    };
+}
+function bracketEnd(text, at) {
+    let depth = 0;
+    for (let i = at; i < text.length; i++) {
+        const ch = text[i];
+        if (ch === "'") {
+            i++;
+        }
+        else if (ch === '[') {
+            depth++;
+        }
+        else if (ch === ']' && --depth === 0) {
+            return i + 1;
+        }
+    }
+    return text.length;
+}
+function emitExternal(state, text) {
+    state.out += text;
+    state.at += text.length;
+    state.sheet = text;
+    state.external = true;
+}
+function emitSheet(state, handlers, prefix) {
+    const name = prefix.startsWith("'")
+        ? prefix.slice(1, -2).replace(/''/g, "'")
+        : prefix.slice(0, -1);
+    if (WORKBOOK.test(name)) {
+        emitExternal(state, prefix);
+        return;
+    }
+    const names = name.split(':');
+    state.sheet = name;
+    state.external = false;
+    state.out += handlers.onSheet ? handlers.onSheet(names, prefix) : prefix;
+    state.at += prefix.length;
+}
+function bracketStep(state, handlers) {
+    const { formula, at } = state;
+    if (formula[at] !== '[') {
+        return false;
+    }
+    const end = bracketEnd(formula, at);
+    let start = at;
+    while (start > 0 && WORD.test(formula[start - 1])) {
+        start--;
+    }
+    const prefix = start === at ? matchAt(BARE_PREFIX, formula, end) : null;
+    if (prefix || (start === at && formula[end] === '!')) {
+        emitExternal(state, formula.slice(at, end) + (prefix ? prefix[0] : '!'));
+        return true;
+    }
+    if (start < at && !state.external) {
+        handlers.onTable?.(formula.slice(start, at));
+    }
+    state.out += formula.slice(at, end);
+    state.at = end;
+    state.sheet = null;
+    state.external = false;
+    return true;
+}
+function quotedStep(state, handlers) {
+    const { formula, at } = state;
+    const ch = formula[at];
+    if (ch !== '"' && ch !== "'") {
+        return false;
+    }
+    const end = quoted(formula, at, ch);
+    if (ch === "'" && formula[end] === '!') {
+        emitSheet(state, handlers, formula.slice(at, end + 1));
+        return true;
+    }
+    state.out += formula.slice(at, end);
+    state.at = end;
+    if (ch === '"') {
+        state.sheet = null;
+    }
+    return true;
+}
+function referenceStep(state, handlers) {
+    const { formula, at } = state;
+    const prev = at > 0 ? formula[at - 1] : '';
+    if (WORD.test(prev) || prev === '$') {
+        return false;
+    }
+    const bare = state.sheet === null && NAME_START.test(formula[at]) ? matchAt(BARE_PREFIX, formula, at) : null;
+    if (bare) {
+        emitSheet(state, handlers, bare[0]);
+        return true;
+    }
+    const ref = readRef(formula, at);
+    if (!ref) {
+        return false;
+    }
+    const original = formula.slice(at, at + ref.length);
+    const next = handlers.onRef && !state.external ? handlers.onRef(ref, { sheet: state.sheet, original }) : null;
+    state.out += next ?? original;
+    state.at += ref.length;
+    state.sheet = null;
+    state.external = false;
+    return true;
+}
+function plainStep(state) {
+    const ch = state.formula[state.at];
+    if (state.sheet !== null && !WORD.test(ch)) {
+        state.sheet = null;
+        state.external = false;
+    }
+    state.out += ch;
+    state.at++;
+}
+export function scan(formula, handlers = {}) {
+    const state = { formula, at: 0, sheet: null, external: false, out: '' };
+    while (state.at < formula.length) {
+        if (!bracketStep(state, handlers) &&
+            !quotedStep(state, handlers) &&
+            !referenceStep(state, handlers)) {
+            plainStep(state);
+        }
+    }
+    return state.out;
+}
+export function sheetsIn(formula) {
+    const found = [];
+    scan(formula, {
+        onSheet: (names, text) => {
+            found.push(...names);
+            return text;
+        }
+    });
+    return found;
+}
+export function tablesIn(formula) {
+    const found = [];
+    scan(formula, { onTable: (name) => found.push(name) });
+    return found;
+}
+export function usesTable(formula, table) {
+    const wanted = table.toLowerCase();
+    return tablesIn(formula).some((name) => name.toLowerCase() === wanted);
+}
+export function mentions(formula, sheet) {
+    const wanted = sheet.toLowerCase();
+    return sheetsIn(formula).some((name) => name.toLowerCase() === wanted);
+}
+export function renameSheet(formula, rename) {
+    const wanted = rename.from.toLowerCase();
+    return scan(formula, {
+        onSheet: (names, text) => {
+            if (!names.some((name) => name.toLowerCase() === wanted)) {
+                return text;
+            }
+            const next = names.map((name) => (name.toLowerCase() === wanted ? rename.to : name));
+            return `${quoteSheets(next)}!`;
+        }
+    });
+}
+function quoteSheets(names) {
+    const quoted = names.map((name) => refs.quoteSheet(name));
+    if (quoted.every((name, i) => name === names[i])) {
+        return names.join(':');
+    }
+    return `'${names.map((name) => name.replace(/'/g, "''")).join(':')}'`;
+}
+function formatCell(p) {
+    return `${p.absCol ? '$' : ''}${refs.column(p.col ?? 0)}${p.absRow ? '$' : ''}${(p.row ?? 0) + 1}`;
+}
+function formatRef(ref) {
+    const { start } = ref;
+    const end = ref.end ?? ref.start;
+    if (ref.kind === 'cell') {
+        return formatCell(start);
+    }
+    if (ref.kind === 'range') {
+        return `${formatCell(start)}:${formatCell(end)}`;
+    }
+    if (ref.kind === 'columns') {
+        return `${start.absCol ? '$' : ''}${refs.column(start.col ?? 0)}:${end.absCol ? '$' : ''}${refs.column(end.col ?? 0)}`;
+    }
+    return `${start.absRow ? '$' : ''}${(start.row ?? 0) + 1}:${end.absRow ? '$' : ''}${(end.row ?? 0) + 1}`;
+}
+function outside(p) {
+    const badCol = p.col !== undefined && (p.col < 0 || p.col >= refs.MAX_COLUMNS);
+    const badRow = p.row !== undefined && (p.row < 0 || p.row >= refs.MAX_ROWS);
+    return badCol || badRow;
+}
+const BROKEN = '\u0000';
+function moved(p, offset) {
+    const col = p.col !== undefined && !p.absCol ? p.col + offset.cols : p.col;
+    const row = p.row !== undefined && !p.absRow ? p.row + offset.rows : p.row;
+    return { ...p, col, row };
+}
+export function shift(formula, offset) {
+    const out = scan(formula, {
+        onRef: (ref) => {
+            const start = moved(ref.start, offset);
+            const end = ref.end ? moved(ref.end, offset) : null;
+            const broken = outside(start) || (end !== null && outside(end));
+            return broken ? BROKEN : formatRef({ ...ref, start, end });
+        }
+    });
+    return out.includes(BROKEN) ? '#REF!' : out;
+}
+function limit(change) {
+    return change.axis === 'row' ? refs.MAX_ROWS : refs.MAX_COLUMNS;
+}
+export function moveIndex(i, change) {
+    const { at, count, kind } = change;
+    if (kind === 'insert') {
+        if (i < at) {
+            return i;
+        }
+        return i + count < limit(change) ? i + count : null;
+    }
+    if (i < at) {
+        return i;
+    }
+    if (i >= at + count) {
+        return i - count;
+    }
+    return null;
+}
+function spanStart(a, change) {
+    if (a < change.at)
+        return a;
+    return a >= change.at + change.count ? a - change.count : change.at;
+}
+function spanEnd(b, change) {
+    if (b < change.at)
+        return b;
+    return b >= change.at + change.count ? b - change.count : change.at - 1;
+}
+export function moveSpan(span, change) {
+    const [a, b] = span;
+    const { at, count } = change;
+    if (change.kind === 'insert') {
+        const last = limit(change) - 1;
+        const first = a >= at ? a + count : a;
+        return first > last ? null : [first, b >= at ? Math.min(b + count, last) : b];
+    }
+    const first = spanStart(a, change);
+    const last = spanEnd(b, change);
+    return last < first ? null : [first, last];
+}
+function adjustRef(ref, change) {
+    const key = change.axis === 'row' ? 'row' : 'col';
+    const from = ref.start[key];
+    if (from === undefined) {
+        return ref;
+    }
+    if (ref.kind === 'cell') {
+        const moved = moveIndex(from, change);
+        return moved === null ? null : { ...ref, start: { ...ref.start, [key]: moved } };
+    }
+    const to = ref.end?.[key];
+    if (!ref.end || to === undefined) {
+        return ref;
+    }
+    const span = moveSpan([from, to], change);
+    if (span === null) {
+        return null;
+    }
+    return { ...ref, start: { ...ref.start, [key]: span[0] }, end: { ...ref.end, [key]: span[1] } };
+}
+export function adjust(formula, ownSheet, change) {
+    const target = change.sheet.toLowerCase();
+    const own = ownSheet ? ownSheet.toLowerCase() : null;
+    return scan(formula, {
+        onRef: (ref, { sheet, original }) => {
+            const pointsAt = sheet !== null ? sheet.toLowerCase() : own;
+            if (pointsAt !== target) {
+                return original;
+            }
+            const moved = adjustRef(ref, change);
+            return moved === null ? '#REF!' : formatRef(moved);
+        }
+    });
+}
+export function references(formula, ownSheet, sheet) {
+    const target = sheet.toLowerCase();
+    const own = ownSheet ? ownSheet.toLowerCase() : null;
+    let hit = false;
+    scan(formula, {
+        onRef: (ref, { sheet: prefix, original }) => {
+            if ((prefix !== null ? prefix.toLowerCase() : own) === target) {
+                hit = true;
+            }
+            return original;
+        }
+    });
+    return hit;
+}
+function plain(p) {
+    return { ...p, absCol: false, absRow: false };
+}
+export function adjustRange(range, change) {
+    const ref = readRef(range, 0);
+    if (!ref || ref.length !== range.length) {
+        return range;
+    }
+    const moved = adjustRef(ref, change);
+    if (moved === null) {
+        return null;
+    }
+    return formatRef({
+        ...moved,
+        start: plain(moved.start),
+        end: moved.end ? plain(moved.end) : null
+    });
+}

package/dist-lib/lib/office/engine/xlsx/index.d.ts

@@ -0,0 +1,8 @@
+import { Workbook } from './workbook.ts';
+import type { OpenOptions } from '../opc/package.ts';
+import type { CreateOptions } from './template.ts';
+export { Workbook };
+export type { SheetRef, SheetInfo, SheetChart, WorkbookRead, Placed, RowSpan, Changed, Renamed, CellCount, Deleted, SheetCount, AddedSheet, CellValue, CellRead, CreateOptions, ReadOptions, CellOptions, CellInput, Cells, InsertRowsOptions, DeleteRowsOptions, DeleteColumnsOptions, ColumnWidthOptions, AddSheetOptions, ImageOptions, SeriesRange, SheetChartSpec } from './workbook.ts';
+export type { CellStyle, CellAlign } from './styles.ts';
+export declare function open(bytes: Uint8Array | ArrayBuffer, opts?: OpenOptions): Workbook;
+export declare function create(opts?: CreateOptions): Workbook;

package/dist-lib/lib/office/engine/xlsx/index.js

@@ -0,0 +1,8 @@
+import { Workbook } from './workbook.js';
+export { Workbook };
+export function open(bytes, opts) {
+    return Workbook.open(bytes, opts);
+}
+export function create(opts) {
+    return Workbook.create(opts);
+}

package/dist-lib/lib/office/engine/xlsx/refs.d.ts

@@ -0,0 +1,22 @@
+export interface Position {
+    row: number;
+    col: number;
+}
+export interface Area {
+    top: number;
+    left: number;
+    bottom: number;
+    right: number;
+}
+export declare const MAX_ROWS = 1048576;
+export declare const MAX_COLUMNS = 16384;
+export declare function column(index: number): string;
+export declare function columnIndex(letters: string): number;
+export declare function cell(row: number, col: number): string;
+export declare function parse(ref: unknown): Position;
+export declare function parseRange(ref: unknown): Area;
+export declare function range(area: Area): string;
+export declare function quoteSheet(name: string): string;
+export declare function absolute(sheet: string, area: Area): string;
+export declare function columnArg(value: unknown): number;
+export declare function rowArg(value: unknown, name?: string): number;

package/dist-lib/lib/office/engine/xlsx/refs.js

@@ -0,0 +1,82 @@
+import { DocsError } from '../errors.js';
+export const MAX_ROWS = 1048576;
+export const MAX_COLUMNS = 16384;
+export function column(index) {
+    let n = index + 1;
+    let out = '';
+    while (n > 0) {
+        const rem = (n - 1) % 26;
+        out = String.fromCharCode(65 + rem) + out;
+        n = Math.floor((n - 1) / 26);
+    }
+    return out;
+}
+export function columnIndex(letters) {
+    let n = 0;
+    for (const ch of letters.toUpperCase()) {
+        n = n * 26 + (ch.charCodeAt(0) - 64);
+    }
+    return n - 1;
+}
+export function cell(row, col) {
+    return `${column(col)}${row + 1}`;
+}
+export function parse(ref) {
+    const match = typeof ref === 'string' ? /^\$?([A-Za-z]{1,3})\$?([0-9]{1,7})$/.exec(ref.trim()) : null;
+    if (!match) {
+        throw new DocsError('INVALID_CELL', `"${String(ref)}" is not a cell reference like A1 or C12`);
+    }
+    const col = columnIndex(match[1]);
+    const row = Number(match[2]) - 1;
+    if (row < 0 || row >= MAX_ROWS || col >= MAX_COLUMNS) {
+        throw new DocsError('INVALID_CELL', `${String(ref)} is outside the sheet`);
+    }
+    return { row, col };
+}
+export function parseRange(ref) {
+    if (typeof ref !== 'string') {
+        throw new DocsError('INVALID_RANGE', 'a range is text like A1:D20');
+    }
+    const [a, b = a] = ref.split(':');
+    const start = parse(a);
+    const end = parse(b);
+    return {
+        top: Math.min(start.row, end.row),
+        left: Math.min(start.col, end.col),
+        bottom: Math.max(start.row, end.row),
+        right: Math.max(start.col, end.col)
+    };
+}
+export function range(area) {
+    const start = cell(area.top, area.left);
+    return area.top === area.bottom && area.left === area.right
+        ? start
+        : `${start}:${cell(area.bottom, area.right)}`;
+}
+export function quoteSheet(name) {
+    return /^[A-Za-z_][A-Za-z0-9_.]*$/.test(name) && !/^[A-Za-z]{1,3}[0-9]+$/.test(name)
+        ? name
+        : `'${name.replace(/'/g, "''")}'`;
+}
+export function absolute(sheet, area) {
+    const start = `$${column(area.left)}$${area.top + 1}`;
+    if (area.top === area.bottom && area.left === area.right) {
+        return `${quoteSheet(sheet)}!${start}`;
+    }
+    return `${quoteSheet(sheet)}!${start}:$${column(area.right)}$${area.bottom + 1}`;
+}
+export function columnArg(value) {
+    if (typeof value === 'string' && /^[A-Za-z]{1,3}$/.test(value)) {
+        return columnIndex(value);
+    }
+    if (typeof value === 'number' && Number.isInteger(value) && value >= 1 && value <= MAX_COLUMNS) {
+        return value - 1;
+    }
+    throw new DocsError('INVALID_CELL', `a column is a letter like "C" or a number from 1, got ${String(value)}`);
+}
+export function rowArg(value, name = 'row') {
+    if (typeof value === 'number' && Number.isInteger(value) && value >= 1 && value <= MAX_ROWS) {
+        return value - 1;
+    }
+    throw new DocsError('INVALID_CELL', `${name} is a row number from 1, got ${String(value)}`);
+}

package/dist-lib/lib/office/engine/xlsx/reshape.d.ts

@@ -0,0 +1,21 @@
+import type { Document, Element } from '../xml.ts';
+import type { Package } from '../opc/package.ts';
+import type { Change } from './formula.ts';
+import type { EditState, Sheet, SheetEntry } from './sheet.ts';
+export interface ReshapeHost {
+    package: Package;
+    main: string;
+    state: EditState;
+    entries(): SheetEntry[];
+    definedNames(): Element[];
+    chartParts(): string[];
+    drawingOf(sheet: Sheet): string | null;
+    sheetFor(entry: SheetEntry): Sheet;
+}
+export declare function formulaElements(doc: Document): Element[];
+export declare function tableNames(pkg: Package, sheetPart: string): string[];
+export declare function renamePivotSources(pkg: Package, from: string, to: string): void;
+export declare function blockers(host: ReshapeHost, sheet: Sheet, change: Change): string[];
+export declare function expandShared(sheet: Sheet): boolean;
+export declare function apply(host: ReshapeHost, target: Sheet, change: Change): void;
+export declare function prepare(host: ReshapeHost, target: Sheet): void;