documents.js 1.57.0 → 1.58.0

package/dist/hsqldb/script.cjs

@@ -0,0 +1,450 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/hsqldb/script.ts
+var HsqldbScriptParseError = class extends Error {
+	statement;
+	constructor(message, statement) {
+		super(`HSQLDB script parse error: ${message} -- in statement: ${truncateForMessage(statement)}`);
+		this.name = "HsqldbScriptParseError";
+		this.statement = statement;
+	}
+};
+const MESSAGE_STATEMENT_PREVIEW_LENGTH = 200;
+function truncateForMessage(statement) {
+	return statement.length > MESSAGE_STATEMENT_PREVIEW_LENGTH ? `${statement.slice(0, MESSAGE_STATEMENT_PREVIEW_LENGTH)}...` : statement;
+}
+function displayTextFor(value) {
+	switch (value.kind) {
+		case "number": return String(value.value);
+		case "percentage": return `${value.value * 100}%`;
+		case "currency": return value.currency === void 0 ? String(value.value) : `${value.value} ${value.currency}`;
+		case "boolean": return value.value ? "TRUE" : "FALSE";
+		case "date":
+		case "time":
+		case "string":
+		case "error": return value.value;
+		case "empty": return "";
+	}
+}
+const IGNORABLE_STATEMENT_PREFIXES = [
+	"SET DATABASE",
+	"SET FILES",
+	"SET SCHEMA",
+	"SET TABLE",
+	"SET WRITE_DELAY",
+	"SET AUTOCOMMIT",
+	"SET IGNORECASE",
+	"SET REFERENTIAL_INTEGRITY",
+	"SET PROPERTY",
+	"SET PASSWORD",
+	"SET LOGSIZE",
+	"SET SCALE",
+	"SET LOCAL",
+	"CREATE USER",
+	"ALTER USER",
+	"DROP USER",
+	"CREATE SCHEMA",
+	"DROP SCHEMA",
+	"GRANT",
+	"REVOKE",
+	"CREATE SEQUENCE",
+	"ALTER SEQUENCE",
+	"DROP SEQUENCE",
+	"CREATE INDEX",
+	"CREATE UNIQUE INDEX",
+	"DROP INDEX",
+	"ALTER TABLE",
+	"CREATE VIEW",
+	"DROP VIEW",
+	"CREATE TRIGGER",
+	"DROP TRIGGER",
+	"CREATE FUNCTION",
+	"CREATE PROCEDURE",
+	"CREATE AGGREGATE FUNCTION",
+	"DROP FUNCTION",
+	"DROP PROCEDURE",
+	"CREATE TYPE",
+	"CREATE DOMAIN",
+	"COMMENT ON",
+	"CHECKPOINT",
+	"CONNECT",
+	"DISCONNECT",
+	"SHUTDOWN"
+];
+function isIgnorableStatement(statement) {
+	const normalized = statement.replace(/\s+/g, " ").trim().toUpperCase();
+	return IGNORABLE_STATEMENT_PREFIXES.some((prefix) => normalized.startsWith(prefix));
+}
+const CREATE_TABLE_RE = /^CREATE\s+(?:(?:MEMORY|CACHED|TEXT|TEMP|TEMPORARY|GLOBAL\s+TEMPORARY)\s+)?TABLE\s+/i;
+const INSERT_INTO_RE = /^INSERT\s+INTO\s+/i;
+const TABLE_CONSTRAINT_KEYWORDS = /* @__PURE__ */ new Set([
+	"PRIMARY",
+	"FOREIGN",
+	"UNIQUE",
+	"CHECK",
+	"CONSTRAINT"
+]);
+function splitStatements(text) {
+	const statements = [];
+	let current = "";
+	let inSingleQuote = false;
+	let inDoubleQuote = false;
+	for (let i = 0; i < text.length; i++) {
+		const ch = text.charAt(i);
+		if (inSingleQuote) {
+			current += ch;
+			if (ch === "'") if (text.charAt(i + 1) === "'") {
+				current += text.charAt(i + 1);
+				i++;
+			} else inSingleQuote = false;
+			continue;
+		}
+		if (inDoubleQuote) {
+			current += ch;
+			if (ch === "\"") if (text.charAt(i + 1) === "\"") {
+				current += text.charAt(i + 1);
+				i++;
+			} else inDoubleQuote = false;
+			continue;
+		}
+		if (ch === "'") {
+			inSingleQuote = true;
+			current += ch;
+			continue;
+		}
+		if (ch === "\"") {
+			inDoubleQuote = true;
+			current += ch;
+			continue;
+		}
+		if (ch === "\n") {
+			const trimmed = current.trim();
+			if (trimmed.length > 0) statements.push(trimmed);
+			current = "";
+			continue;
+		}
+		current += ch;
+	}
+	const tail = current.trim();
+	if (tail.length > 0) statements.push(tail);
+	return statements;
+}
+function skipWs(s, start) {
+	let i = start;
+	while (i < s.length && /\s/.test(s.charAt(i))) i++;
+	return i;
+}
+function readIdentifier(s, start) {
+	const i0 = skipWs(s, start);
+	if (s.charAt(i0) === "\"") {
+		let name = "";
+		let i = i0 + 1;
+		while (i < s.length) {
+			const ch = s.charAt(i);
+			if (ch === "\"") {
+				if (s.charAt(i + 1) === "\"") {
+					name += "\"";
+					i += 2;
+					continue;
+				}
+				i++;
+				break;
+			}
+			name += ch;
+			i++;
+		}
+		return {
+			name,
+			next: i
+		};
+	}
+	let i = i0;
+	while (i < s.length && /[A-Za-z0-9_$#]/.test(s.charAt(i))) i++;
+	return {
+		name: s.slice(i0, i),
+		next: i
+	};
+}
+function readQualifiedName(s, start) {
+	const first = readIdentifier(s, start);
+	let last = first.name;
+	let i = first.next;
+	while (s.charAt(i) === ".") {
+		const segment = readIdentifier(s, i + 1);
+		last = segment.name;
+		i = segment.next;
+	}
+	return {
+		last,
+		next: i
+	};
+}
+function readBalancedParens(s, openIndex) {
+	let depth = 0;
+	let inSingleQuote = false;
+	let inDoubleQuote = false;
+	let i = openIndex;
+	for (; i < s.length; i++) {
+		const ch = s.charAt(i);
+		if (inSingleQuote) {
+			if (ch === "'") {
+				if (s.charAt(i + 1) === "'") {
+					i++;
+					continue;
+				}
+				inSingleQuote = false;
+			}
+			continue;
+		}
+		if (inDoubleQuote) {
+			if (ch === "\"") {
+				if (s.charAt(i + 1) === "\"") {
+					i++;
+					continue;
+				}
+				inDoubleQuote = false;
+			}
+			continue;
+		}
+		if (ch === "'") {
+			inSingleQuote = true;
+			continue;
+		}
+		if (ch === "\"") {
+			inDoubleQuote = true;
+			continue;
+		}
+		if (ch === "(") {
+			depth++;
+			continue;
+		}
+		if (ch === ")") {
+			depth--;
+			if (depth === 0) return {
+				inner: s.slice(openIndex + 1, i),
+				next: i + 1
+			};
+		}
+	}
+	throw new HsqldbScriptParseError("unterminated parenthesis", s);
+}
+function splitTopLevel(s, sep) {
+	const parts = [];
+	let current = "";
+	let depth = 0;
+	let inSingleQuote = false;
+	let inDoubleQuote = false;
+	for (let i = 0; i < s.length; i++) {
+		const ch = s.charAt(i);
+		if (inSingleQuote) {
+			current += ch;
+			if (ch === "'") if (s.charAt(i + 1) === "'") {
+				current += s.charAt(i + 1);
+				i++;
+			} else inSingleQuote = false;
+			continue;
+		}
+		if (inDoubleQuote) {
+			current += ch;
+			if (ch === "\"") if (s.charAt(i + 1) === "\"") {
+				current += s.charAt(i + 1);
+				i++;
+			} else inDoubleQuote = false;
+			continue;
+		}
+		if (ch === "'") {
+			inSingleQuote = true;
+			current += ch;
+			continue;
+		}
+		if (ch === "\"") {
+			inDoubleQuote = true;
+			current += ch;
+			continue;
+		}
+		if (ch === "(") {
+			depth++;
+			current += ch;
+			continue;
+		}
+		if (ch === ")") {
+			depth--;
+			current += ch;
+			continue;
+		}
+		if (ch === sep && depth === 0) {
+			parts.push(current);
+			current = "";
+			continue;
+		}
+		current += ch;
+	}
+	parts.push(current);
+	return parts;
+}
+function unescapeSingleQuotes(s) {
+	return s.replace(/''/g, "'");
+}
+function typeBucket(typeText) {
+	const word = /^([A-Za-z_]+)/.exec(typeText.trim())?.[1]?.toUpperCase();
+	if (word === "DATE") return "date";
+	if (word === "TIME") return "time";
+	return "other";
+}
+const NUMBER_LITERAL_RE = /^[-+]?\d+(?:\.\d+)?(?:[eE][-+]?\d+)?$/;
+function parseLiteral(raw, bucket) {
+	const trimmed = raw.trim();
+	if (/^NULL$/i.test(trimmed)) return { kind: "empty" };
+	const dateTyped = /^DATE\s*'((?:[^']|'')*)'$/i.exec(trimmed);
+	if (dateTyped?.[1] !== void 0) return {
+		kind: "date",
+		value: unescapeSingleQuotes(dateTyped[1])
+	};
+	const timeTyped = /^TIME\s*'((?:[^']|'')*)'$/i.exec(trimmed);
+	if (timeTyped?.[1] !== void 0) return {
+		kind: "time",
+		value: unescapeSingleQuotes(timeTyped[1])
+	};
+	const timestampTyped = /^TIMESTAMP\s*'((?:[^']|'')*)'$/i.exec(trimmed);
+	if (timestampTyped?.[1] !== void 0) return {
+		kind: "date",
+		value: unescapeSingleQuotes(timestampTyped[1])
+	};
+	if (trimmed.length >= 2 && trimmed.startsWith("'") && trimmed.endsWith("'")) {
+		const text = unescapeSingleQuotes(trimmed.slice(1, -1));
+		if (bucket === "date") return {
+			kind: "date",
+			value: text
+		};
+		if (bucket === "time") return {
+			kind: "time",
+			value: text
+		};
+		return {
+			kind: "string",
+			value: text
+		};
+	}
+	if (/^TRUE$/i.test(trimmed)) return {
+		kind: "boolean",
+		value: true
+	};
+	if (/^FALSE$/i.test(trimmed)) return {
+		kind: "boolean",
+		value: false
+	};
+	if (NUMBER_LITERAL_RE.test(trimmed)) return {
+		kind: "number",
+		value: Number(trimmed)
+	};
+	throw new HsqldbScriptParseError(`unrecognised literal "${trimmed}"`, raw);
+}
+function parseCreateTable(statement) {
+	const match = CREATE_TABLE_RE.exec(statement);
+	if (match === null) throw new HsqldbScriptParseError("expected a CREATE TABLE statement", statement);
+	const afterKeyword = match[0].length;
+	const { last: tableName, next } = readQualifiedName(statement, afterKeyword);
+	const openIndex = skipWs(statement, next);
+	if (statement.charAt(openIndex) !== "(") throw new HsqldbScriptParseError(`CREATE TABLE "${tableName}": expected "(" to start the column list`, statement);
+	const { inner } = readBalancedParens(statement, openIndex);
+	const columns = [];
+	for (const rawPart of splitTopLevel(inner, ",")) {
+		const part = rawPart.trim();
+		if (part.length === 0) continue;
+		const leadingWord = /^([A-Za-z_][A-Za-z0-9_]*)/.exec(part)?.[1]?.toUpperCase();
+		if (leadingWord !== void 0 && TABLE_CONSTRAINT_KEYWORDS.has(leadingWord)) continue;
+		const { name, next: afterName } = readIdentifier(part, 0);
+		if (name.length === 0) throw new HsqldbScriptParseError(`CREATE TABLE "${tableName}": could not read a column name from "${part}"`, statement);
+		columns.push({
+			name,
+			type: part.slice(afterName).trim()
+		});
+	}
+	if (columns.length === 0) throw new HsqldbScriptParseError(`CREATE TABLE "${tableName}": no columns found`, statement);
+	return {
+		tableName,
+		columns
+	};
+}
+function parseInsertInto(statement) {
+	const match = INSERT_INTO_RE.exec(statement);
+	if (match === null) throw new HsqldbScriptParseError("expected an INSERT INTO statement", statement);
+	const { last: tableName, next } = readQualifiedName(statement, match[0].length);
+	let i = skipWs(statement, next);
+	let explicitColumns;
+	if (statement.charAt(i) === "(") {
+		const { inner, next: afterCols } = readBalancedParens(statement, i);
+		explicitColumns = splitTopLevel(inner, ",").map((part) => readIdentifier(part.trim(), 0).name);
+		i = skipWs(statement, afterCols);
+	}
+	const valuesMatch = /^VALUES\s*/i.exec(statement.slice(i));
+	if (valuesMatch === null) throw new HsqldbScriptParseError(`INSERT INTO "${tableName}": expected the VALUES keyword`, statement);
+	i = skipWs(statement, i + valuesMatch[0].length);
+	if (statement.charAt(i) !== "(") throw new HsqldbScriptParseError(`INSERT INTO "${tableName}": expected "(" to start the VALUES tuple`, statement);
+	const { inner, next: afterTuple } = readBalancedParens(statement, i);
+	const trailing = statement.slice(afterTuple).trim();
+	if (trailing.length > 0) throw new HsqldbScriptParseError(`INSERT INTO "${tableName}": unexpected trailing content after the VALUES tuple ("${trailing}") -- multiple tuples per INSERT are outside this bounded parser's scope`, statement);
+	return {
+		tableName,
+		explicitColumns,
+		values: splitTopLevel(inner, ",").map((value) => value.trim())
+	};
+}
+function resolveColumnOrder(table, explicitColumns, statement) {
+	if (explicitColumns === void 0) return table.columns.map((_, index) => index);
+	return explicitColumns.map((name) => {
+		const index = table.columns.findIndex((column) => column.name.toUpperCase() === name.toUpperCase());
+		if (index === -1) throw new HsqldbScriptParseError(`INSERT INTO "${table.tableName}": column "${name}" is not declared on this table`, statement);
+		return index;
+	});
+}
+function parseHsqldbScript(bytes) {
+	const text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+	const tablesByKey = /* @__PURE__ */ new Map();
+	const order = [];
+	for (const statement of splitStatements(text)) {
+		if (CREATE_TABLE_RE.test(statement)) {
+			const { tableName, columns } = parseCreateTable(statement);
+			const key = tableName.toUpperCase();
+			if (tablesByKey.has(key)) throw new HsqldbScriptParseError(`duplicate CREATE TABLE for "${tableName}"`, statement);
+			tablesByKey.set(key, {
+				tableName,
+				columns,
+				rows: []
+			});
+			order.push(key);
+			continue;
+		}
+		if (INSERT_INTO_RE.test(statement)) {
+			const { tableName, explicitColumns, values } = parseInsertInto(statement);
+			const key = tableName.toUpperCase();
+			const table = tablesByKey.get(key);
+			if (table === void 0) throw new HsqldbScriptParseError(`INSERT INTO references unknown table "${tableName}" (no prior CREATE TABLE seen for it)`, statement);
+			const columnOrder = resolveColumnOrder(table, explicitColumns, statement);
+			if (values.length !== columnOrder.length) throw new HsqldbScriptParseError(`INSERT INTO "${tableName}": expected ${columnOrder.length} value(s), found ${values.length}`, statement);
+			const row = table.columns.map(() => ({ kind: "empty" }));
+			columnOrder.forEach((columnIndex, position) => {
+				const column = table.columns[columnIndex];
+				const rawValue = values[position];
+				if (column === void 0 || rawValue === void 0) throw new HsqldbScriptParseError(`INSERT INTO "${tableName}": internal column/value alignment failure`, statement);
+				row[columnIndex] = parseLiteral(rawValue, typeBucket(column.type));
+			});
+			table.rows.push(row);
+			continue;
+		}
+		if (isIgnorableStatement(statement)) continue;
+		throw new HsqldbScriptParseError("unrecognised statement (not CREATE TABLE, INSERT INTO, or a known ignorable statement kind)", statement);
+	}
+	return order.map((key) => {
+		const table = tablesByKey.get(key);
+		if (table === void 0) throw new HsqldbScriptParseError(`internal error: table "${key}" missing from tracking map`, "");
+		return {
+			tableName: table.tableName,
+			columns: table.columns,
+			rows: table.rows
+		};
+	});
+}
+//#endregion
+exports.HsqldbScriptParseError = HsqldbScriptParseError;
+exports.displayTextFor = displayTextFor;
+exports.parseHsqldbScript = parseHsqldbScript;

package/dist/hsqldb/script.d.cts

@@ -0,0 +1,19 @@
+import { ContentCellValue } from "document-schema.js";
+//#region src/hsqldb/script.d.ts
+declare class HsqldbScriptParseError extends Error {
+  readonly statement: string;
+  constructor(message: string, statement: string);
+}
+interface HsqldbColumn {
+  readonly name: string;
+  readonly type: string;
+}
+interface HsqldbTable {
+  readonly tableName: string;
+  readonly columns: readonly HsqldbColumn[];
+  readonly rows: readonly (readonly ContentCellValue[])[];
+}
+declare function displayTextFor(value: ContentCellValue): string;
+declare function parseHsqldbScript(bytes: Uint8Array): HsqldbTable[];
+//#endregion
+export { HsqldbColumn, HsqldbScriptParseError, HsqldbTable, displayTextFor, parseHsqldbScript };

package/dist/hsqldb/script.d.ts

@@ -0,0 +1,19 @@
+import { ContentCellValue } from "document-schema.js";
+//#region src/hsqldb/script.d.ts
+declare class HsqldbScriptParseError extends Error {
+  readonly statement: string;
+  constructor(message: string, statement: string);
+}
+interface HsqldbColumn {
+  readonly name: string;
+  readonly type: string;
+}
+interface HsqldbTable {
+  readonly tableName: string;
+  readonly columns: readonly HsqldbColumn[];
+  readonly rows: readonly (readonly ContentCellValue[])[];
+}
+declare function displayTextFor(value: ContentCellValue): string;
+declare function parseHsqldbScript(bytes: Uint8Array): HsqldbTable[];
+//#endregion
+export { HsqldbColumn, HsqldbScriptParseError, HsqldbTable, displayTextFor, parseHsqldbScript };