@protobase/ui 0.19.3 → 0.19.5

package/dist/app/import/locale-formats.js

@@ -0,0 +1,15 @@
+//#region src/app/import/locale-formats.ts
+/**
+* How the browser's locale writes numbers and dates, as the import's starting choice: its decimal separator, and whether
+* its dates put the day or the month first. The user sees both and can change them.
+*/
+const localeFormats = (locale) => {
+	const decimal = new Intl.NumberFormat(locale).formatToParts(1.5).find((part) => part.type === "decimal")?.value === "," ? "," : ".";
+	const parts = new Intl.DateTimeFormat(locale).formatToParts(new Date(2026, 3, 3)).map((part) => part.type);
+	return {
+		decimal,
+		dateOrder: parts.indexOf("month") < parts.indexOf("day") ? "mdy" : "dmy"
+	};
+};
+//#endregion
+export { localeFormats };

package/dist/app/import/lookups.js

@@ -0,0 +1,48 @@
+import { createWhere, printFilter } from "@protobase/schema";
+//#region src/app/import/lookups.ts
+const where = createWhere();
+const valuesPerRequest = 100;
+/** A value as the lookups compare it: the API answers numbers as numbers and the rest as text. */
+const lookupKey = (value) => String(value);
+/**
+* Finds records by the value of a field, for the relations of an import's rows and the records it updates: each value
+* is asked for once per import, a hundred at a time, and remembered.
+*/
+const createLookups = (clientFor) => {
+	const known = /* @__PURE__ */ new Map();
+	const foundOf = (resource, field) => {
+		const id = `${resource}.${field}`;
+		if (!known.has(id)) known.set(id, /* @__PURE__ */ new Map());
+		return known.get(id);
+	};
+	/** Asks the API for the values not asked for yet; the user reads only the records they may list. */
+	const load = async (model, field, values) => {
+		const found = foundOf(model.name, field);
+		const missing = [...new Map(values.filter((value) => !found.has(lookupKey(value))).map((value) => [lookupKey(value), value])).values()];
+		const key = model.primaryKey[0];
+		for (let at = 0; at < missing.length; at += valuesPerRequest) {
+			const asked = missing.slice(at, at + valuesPerRequest);
+			for (const value of asked) found.set(lookupKey(value), []);
+			const filter = printFilter(where.in(field, asked));
+			let pageToken;
+			do {
+				const page = await clientFor(model.name).list(model.name, {
+					filter,
+					fields: [.../* @__PURE__ */ new Set([key, field])],
+					pageSize: 1e3,
+					pageToken
+				});
+				for (const record of page.items) found.get(lookupKey(record[field]))?.push(record[key]);
+				pageToken = page.nextPageToken || void 0;
+			} while (pageToken);
+		}
+	};
+	/** The keys of the records found by the value, once `load` asked for it. */
+	const keysOf = (resource, field, value) => foundOf(resource, field).get(lookupKey(value)) ?? [];
+	return {
+		load,
+		keysOf
+	};
+};
+//#endregion
+export { createLookups, lookupKey };

package/dist/app/import/mapping.js

@@ -0,0 +1,78 @@
+import { humanize } from "../../live/naming.js";
+//#region src/app/import/mapping.ts
+/** How a field reads in the import: its view's label, as everywhere else in the app. */
+const fieldLabel = (view, name) => view?.fields[name]?.label ?? humanize(name);
+const importableTypes = /* @__PURE__ */ new Set([
+	"text",
+	"integer",
+	"bigint",
+	"decimal",
+	"boolean",
+	"date",
+	"timestamp",
+	"uuid",
+	"enum",
+	"relation",
+	"currency",
+	"country"
+]);
+const relationTarget = (field, resources) => {
+	const target = field.relation ? resources[field.relation.resource] : void 0;
+	return target?.primaryKey.length === 1 ? target : void 0;
+};
+/** The fields an import may write: not read-only, not the tenant, and of a type a cell can hold. */
+const importableFields = (model, resources) => Object.values(model.fields).filter((field) => {
+	if (field.readOnly || field.name === model.tenant || !importableTypes.has(field.type)) return false;
+	return field.type !== "relation" || relationTarget(field, resources) !== void 0;
+});
+const matchableTypes = /* @__PURE__ */ new Set([
+	"text",
+	"integer",
+	"bigint",
+	"uuid",
+	"date",
+	"currency",
+	"country",
+	"enum"
+]);
+/**
+* The fields records of `model` can be found by: its key when it is one field, then the filterable fields whose values
+* single records out, such as an email or an order number. The user says which is unique; a value that matches several
+* records is an error on its row.
+*/
+const matchFields = (model) => {
+	const key = model.primaryKey.length === 1 ? [model.fields[model.primaryKey[0]]] : [];
+	const others = Object.values(model.fields).filter((field) => field.filterable && !field.sensitive && matchableTypes.has(field.type) && !model.primaryKey.includes(field.name));
+	return [...key, ...others];
+};
+/** The resource a relation field points at, when an import can fill it. */
+const relationModel = (field, resources) => relationTarget(field, resources);
+/** Whether a new record needs the field: it can be neither empty nor filled in by a default. */
+const requiredOnCreate = (field) => !field.nullable && !field.default;
+const normalized = (text) => text.toLowerCase().replace(/[\s_-]+/g, "");
+/**
+* Each column whose header is a field's label or name, ignoring case and spacing, mapped to that field; a field takes
+* the first column that matches it, and a column that matches none is skipped.
+*/
+const autoMapping = (headers, fields, view) => {
+	const taken = /* @__PURE__ */ new Set();
+	return headers.flatMap((header, column) => {
+		const text = normalized(header);
+		if (text === "") return [];
+		const field = fields.find((candidate) => !taken.has(candidate.name) && (normalized(fieldLabel(view, candidate.name)) === text || normalized(candidate.name) === text));
+		if (!field) return [];
+		taken.add(field.name);
+		return [{
+			column,
+			field: field.name
+		}];
+	});
+};
+/** The fields a new record needs that no column fills, which a create, or a create-or-update, must have. */
+const unmappedRequired = (mode, fields, mapping) => {
+	if (mode === "update") return [];
+	const mapped = new Set(mapping.map((entry) => entry.field));
+	return fields.filter((field) => requiredOnCreate(field) && !mapped.has(field.name));
+};
+//#endregion
+export { autoMapping, fieldLabel, importableFields, matchFields, relationModel, requiredOnCreate, unmappedRequired };

package/dist/app/import/parse-worker.d.ts

@@ -0,0 +1 @@
+export {}

package/dist/app/import/parse-worker.js

@@ -0,0 +1,39 @@
+import { sheetNames, sheetRows } from "./sheet-file.js";
+//#region src/app/import/parse-worker.ts
+const scope = self;
+const reply = (message) => scope.postMessage(message);
+let next;
+const read = async (request) => {
+	let chunk = [];
+	for await (const row of sheetRows(request.file, request.sheet)) {
+		chunk.push(row);
+		if (chunk.length < request.chunk) continue;
+		const asked = new Promise((resolve) => next = resolve);
+		reply({
+			type: "rows",
+			rows: chunk
+		});
+		chunk = [];
+		await asked;
+	}
+	reply({
+		type: "rows",
+		rows: chunk
+	});
+	reply({ type: "end" });
+};
+const handle = async (request) => {
+	if (request.type === "next") return next?.();
+	if (request.type === "sheets") return reply({
+		type: "sheets",
+		sheets: await sheetNames(request.file)
+	});
+	await read(request);
+};
+scope.onmessage = (event) => {
+	handle(event.data).catch((error) => reply({
+		type: "error",
+		message: error instanceof Error ? error.message : String(error)
+	}));
+};
+//#endregion

package/dist/app/import/prepare-rows.js

@@ -0,0 +1,129 @@
+import { humanize } from "../../live/naming.js";
+import { cellText, isEmptyCell } from "./sheet-cell.js";
+import { fieldLabel, relationModel } from "./mapping.js";
+import { convertCell } from "./convert.js";
+//#region src/app/import/prepare-rows.ts
+const singularOf = (views, resource) => views[resource]?.names?.singular ?? humanize(resource);
+const pluralOf = (views, resource) => views[resource]?.names?.plural ?? humanize(resource);
+const convertRow = (row, plan, context) => {
+	const { model, resources, views } = context;
+	const view = views[model.name];
+	const values = {};
+	const data = {};
+	const problems = [];
+	const relations = [];
+	for (const { column, field: name, matchBy } of plan.columns) {
+		const field = model.fields[name];
+		const cell = row.cells[column] ?? null;
+		const label = fieldLabel(view, name);
+		const target = relationModel(field, resources);
+		if (target && !isEmptyCell(cell)) {
+			const by = matchBy ?? target.primaryKey[0];
+			const converted = convertCell(target.fields[by], views[target.name]?.fields[by], cell, plan.options);
+			if (!converted.ok) problems.push(`${label}: ${converted.problem}`);
+			else relations.push({
+				field: name,
+				finding: {
+					model: target,
+					field: by,
+					value: converted.value
+				}
+			});
+			values[name] = cellText(cell);
+			continue;
+		}
+		const converted = convertCell(field, view?.fields[name], cell, plan.options);
+		if (!converted.ok) problems.push(`${label}: ${converted.problem}`);
+		else data[name] = values[name] = converted.value;
+	}
+	let match;
+	if (plan.match && plan.mode !== "create") {
+		const field = model.fields[plan.match.field];
+		const converted = convertCell({
+			...field,
+			nullable: false
+		}, view?.fields[field.name], row.cells[plan.match.column] ?? null, plan.options);
+		if (!converted.ok) problems.push(`${fieldLabel(view, field.name)}: ${converted.problem}`);
+		else match = {
+			model,
+			field: field.name,
+			value: converted.value
+		};
+	}
+	return {
+		values,
+		data,
+		problems,
+		relations,
+		match
+	};
+};
+const foundOne = (context, finding) => {
+	const keys = context.lookups.keysOf(finding.model.name, finding.field, finding.value);
+	const named = `${fieldLabel(context.views[finding.model.name], finding.field).toLowerCase()} “${String(finding.value)}”`;
+	if (keys.length === 1) return { key: keys[0] };
+	if (keys.length === 0) return { none: `no ${singularOf(context.views, finding.model.name).toLowerCase()} has ${named}` };
+	return { several: `${keys.length} ${pluralOf(context.views, finding.model.name).toLowerCase()} have ${named}` };
+};
+const isBlank = (row) => row.cells.every(isEmptyCell);
+/**
+* The rows of a chunk as writes: each mapped cell converted, related records and the records to update found (asked
+* for together), and the write each row makes, or the problems that keep it out. Rows with no value at all are left
+* out.
+*/
+const prepareRows = async (rows, plan, context) => {
+	const { model, views } = context;
+	const converted = rows.filter((row) => !isBlank(row)).map((row) => ({
+		row,
+		...convertRow(row, plan, context)
+	}));
+	const wanted = /* @__PURE__ */ new Map();
+	for (const finding of converted.flatMap((entry) => [...entry.relations.map((relation) => relation.finding), ...entry.match ? [entry.match] : []])) {
+		const id = `${finding.model.name}.${finding.field}`;
+		if (!wanted.has(id)) wanted.set(id, {
+			model: finding.model,
+			field: finding.field,
+			values: []
+		});
+		wanted.get(id).values.push(finding.value);
+	}
+	for (const { model: target, field, values } of wanted.values()) await context.lookups.load(target, field, values);
+	return converted.map(({ row, values, data, problems, relations, match }) => {
+		const written = { ...data };
+		for (const { field, finding } of relations) {
+			const found = foundOne(context, finding);
+			if ("key" in found) written[field] = found.key;
+			else problems.push(`${fieldLabel(views[model.name], field)}: ${found.none ?? found.several}`);
+		}
+		const existing = match && foundOne(context, match);
+		if (existing?.several) problems.push(`Not one record: ${existing.several}`);
+		if (existing?.none && plan.mode === "update") problems.push(`Nothing to update: ${existing.none}`);
+		const prepared = {
+			line: row.line,
+			cells: row.cells,
+			values,
+			problems
+		};
+		if (problems.length > 0) return prepared;
+		if (existing && "key" in existing) return {
+			...prepared,
+			op: {
+				op: "update",
+				resource: model.name,
+				key: existing.key,
+				etag: "*",
+				data: written
+			}
+		};
+		return {
+			...prepared,
+			op: {
+				op: "create",
+				resource: model.name,
+				data: written
+			}
+		};
+	});
+};
+//#endregion
+export { prepareRows };

package/dist/app/import/run-import.js

@@ -0,0 +1,130 @@
+import { cellText } from "./sheet-cell.js";
+import { fieldLabel } from "./mapping.js";
+import { prepareRows } from "./prepare-rows.js";
+import { isApiError } from "@protobase/client";
+//#region src/app/import/run-import.ts
+/** How many data rows the mapping step shows under each column. */
+const sampleRows = 5;
+/** How many rows of the check the preview shows. */
+const previewRows = 5;
+/** The header and the first rows of a sheet, reading no further than its first chunk. */
+const readHead = async (source, sheet) => {
+	const chunks = source.rows(sheet);
+	const { value: first = [] } = await chunks.next();
+	await chunks.return(void 0);
+	const [header, ...rows] = first;
+	return {
+		headers: (header?.cells ?? []).map(cellText),
+		sample: rows.slice(0, sampleRows)
+	};
+};
+async function* dataRows(source, sheet) {
+	let header = true;
+	for await (const chunk of source.rows(sheet)) {
+		yield header ? chunk.slice(1) : chunk;
+		header = false;
+	}
+}
+/** Reads the whole file and prepares every row as the import would, writing nothing; `onProgress` gets the rows read so far. */
+const checkImport = async (source, sheet, plan, context, onProgress, signal) => {
+	const check = {
+		rows: 0,
+		creates: 0,
+		updates: 0,
+		problems: [],
+		preview: []
+	};
+	for await (const chunk of dataRows(source, sheet)) {
+		signal?.throwIfAborted();
+		for (const row of await prepareRows(chunk, plan, context)) {
+			check.rows++;
+			if (check.preview.length < previewRows) check.preview.push(row);
+			if (row.op?.op === "create") check.creates++;
+			else if (row.op?.op === "update") check.updates++;
+			else check.problems.push({
+				line: row.line,
+				cells: row.cells,
+				problems: row.problems
+			});
+		}
+		onProgress(check.rows);
+	}
+	return check;
+};
+const refusal = (error, context) => {
+	if (!isApiError(error)) return [error.message];
+	const fields = error.errors.filter((entry) => entry.field);
+	if (fields.length === 0) return [error.message];
+	return fields.map((entry) => `${fieldLabel(context.views[context.model.name], entry.field)}: ${entry.message}`);
+};
+/**
+* Writes the file's rows in batches of `batchRows`, each batch one transaction through `POST :batchWrite`, with the
+* same validation and access as single writes. A row the server refuses is set aside with the reason, and the rest of
+* its batch is sent again, so every row that can be written is. Rows with problems are skipped. Answers `cancelled`
+* when stopped between batches; an error other than a refused row stops the import and is thrown.
+*/
+const runImport = async (source, sheet, plan, context, { client, onProgress, cancelled }) => {
+	const progress = {
+		created: 0,
+		updated: 0,
+		skipped: 0,
+		failed: 0,
+		notWritten: []
+	};
+	const write = async (rows) => {
+		const pending = [...rows];
+		while (pending.length > 0) {
+			const ops = pending.map((row) => row.op);
+			try {
+				const { results } = await client.batchWrite(ops);
+				for (const result of results) if (result.op === "create") progress.created++;
+				else if (result.op === "update") progress.updated++;
+				return;
+			} catch (error) {
+				const index = isApiError(error) ? error.operation : void 0;
+				if (index === void 0 || !pending[index]) throw error;
+				const [refused] = pending.splice(index, 1);
+				progress.failed++;
+				progress.notWritten.push({
+					line: refused.line,
+					cells: refused.cells,
+					problems: refusal(error, context)
+				});
+			}
+		}
+	};
+	let queue = [];
+	const flush = async (all) => {
+		while (queue.length >= 100 || all && queue.length > 0) {
+			if (cancelled()) return false;
+			await write(queue.splice(0, 100));
+			onProgress({ ...progress });
+		}
+		return true;
+	};
+	for await (const chunk of dataRows(source, sheet)) {
+		for (const row of await prepareRows(chunk, plan, context)) if (row.op) queue.push(row);
+		else {
+			progress.skipped++;
+			progress.notWritten.push({
+				line: row.line,
+				cells: row.cells,
+				problems: row.problems
+			});
+		}
+		if (!await flush(false)) return {
+			...progress,
+			cancelled: true
+		};
+	}
+	if (!await flush(true)) return {
+		...progress,
+		cancelled: true
+	};
+	return {
+		...progress,
+		cancelled: false
+	};
+};
+//#endregion
+export { checkImport, readHead, runImport };

package/dist/app/import/sheet-cell.js

@@ -0,0 +1,17 @@
+//#region src/app/import/sheet-cell.ts
+const isSheetDate = (cell) => typeof cell === "object" && cell !== null;
+/** Whether the cell holds nothing: no value, or only spaces. */
+const isEmptyCell = (cell) => cell === null || typeof cell === "string" && cell.trim() === "";
+/** The cell as the file shows it, for a header, a preview or the file of failed rows. */
+const cellText = (cell) => {
+	if (cell === null) return "";
+	if (isSheetDate(cell)) return cell.date.replace("T", " ");
+	if (typeof cell === "boolean") return cell ? "TRUE" : "FALSE";
+	return String(cell);
+};
+/** A column's letters as a spreadsheet names it: 0 is A, 27 is AB. */
+const columnLetters = (index) => index < 26 ? String.fromCharCode(65 + index) : columnLetters(Math.floor(index / 26) - 1) + columnLetters(index % 26);
+/** How the import names a column: its header, or "Column C" when the header cell is empty. */
+const columnName = (headers, index) => headers[index]?.trim() ? headers[index] : `Column ${columnLetters(index)}`;
+//#endregion
+export { cellText, columnLetters, columnName, isEmptyCell, isSheetDate };

package/dist/app/import/sheet-file.js

@@ -0,0 +1,58 @@
+import { createCsvParser } from "./csv-parser.js";
+import { openWorkbook } from "./xlsx-reader.js";
+//#region src/app/import/sheet-file.ts
+const startsAsZip = async (file) => {
+	const head = new Uint8Array(await file.slice(0, 2).arrayBuffer());
+	return head[0] === 80 && head[1] === 75;
+};
+/** Whether the file is a workbook or CSV text: by its name's extension, else by whether it is a ZIP archive. */
+const sheetFormat = async (file) => {
+	const extension = /\.([^.]+)$/.exec(file.name)?.[1]?.toLowerCase();
+	if (extension === "xlsx") return "xlsx";
+	if (extension === "csv" || extension === "tsv" || extension === "txt") return "csv";
+	return await startsAsZip(file) ? "xlsx" : "csv";
+};
+/** The workbook's sheet names, in order; a CSV has none. */
+const sheetNames = async (file) => await sheetFormat(file) === "xlsx" ? (await openWorkbook(file)).sheets : [];
+const notText = () => /* @__PURE__ */ new Error("The file is not UTF-8 text. Save it as \"CSV UTF-8\" and choose it again.");
+async function* csvRows(file) {
+	const parser = createCsvParser();
+	const decoder = new TextDecoder("utf-8", { fatal: true });
+	const decode = (bytes) => {
+		try {
+			return bytes ? decoder.decode(bytes, { stream: true }) : decoder.decode();
+		} catch (error) {
+			if (error instanceof TypeError) throw notText();
+			throw error;
+		}
+	};
+	const reader = file.stream().getReader();
+	let line = 0;
+	const numbered = (rows) => rows.map((cells) => ({
+		line: ++line,
+		cells
+	}));
+	try {
+		for (;;) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			yield* numbered(parser.push(decode(value)));
+		}
+		yield* numbered([...parser.push(decode()), ...parser.end()]);
+	} finally {
+		await reader.cancel();
+	}
+}
+/**
+* The rows of the file, the header first, read as the file streams in: a CSV's (UTF-8, with its delimiter found from
+* the header line), or the named sheet of a workbook.
+*/
+async function* sheetRows(file, sheet) {
+	if (await sheetFormat(file) === "csv") return yield* csvRows(file);
+	const workbook = await openWorkbook(file);
+	const name = sheet ?? workbook.sheets[0];
+	if (name === void 0) throw new Error("The workbook has no sheets");
+	yield* workbook.rows(name);
+}
+//#endregion
+export { sheetFormat, sheetNames, sheetRows };

package/dist/app/import/sheet-source.js

@@ -0,0 +1,72 @@
+//#region src/app/import/sheet-source.ts
+/** How many rows the worker sends at a time. */
+const chunkRows = 500;
+const startWorker = () => {
+	const worker = new Worker(new URL("./parse-worker.js", import.meta.url), { type: "module" });
+	const replies = [];
+	let waiting;
+	worker.onmessage = (event) => {
+		if (waiting) {
+			const resolve = waiting;
+			waiting = void 0;
+			resolve(event.data);
+		} else replies.push(event.data);
+	};
+	worker.onerror = (event) => {
+		event.preventDefault();
+		const failed = {
+			type: "error",
+			message: "The file could not be read"
+		};
+		if (waiting) waiting(failed);
+		else replies.push(failed);
+	};
+	const send = (request) => worker.postMessage(request);
+	const receive = () => replies.length > 0 ? Promise.resolve(replies.shift()) : new Promise((resolve) => waiting = resolve);
+	return {
+		send,
+		receive,
+		stop: () => worker.terminate()
+	};
+};
+/** The file read by a Web Worker, so parsing never holds up the page; each read has a worker of its own. */
+const workerSheetSource = (file) => ({
+	sheets: async () => {
+		const worker = startWorker();
+		try {
+			worker.send({
+				type: "sheets",
+				file
+			});
+			const reply = await worker.receive();
+			if (reply.type === "error") throw new Error(reply.message);
+			if (reply.type !== "sheets") throw new Error(`The parse worker answered ${reply.type} to a request for sheets`);
+			return reply.sheets;
+		} finally {
+			worker.stop();
+		}
+	},
+	rows: async function* (sheet) {
+		const worker = startWorker();
+		try {
+			worker.send({
+				type: "read",
+				file,
+				sheet,
+				chunk: chunkRows
+			});
+			for (;;) {
+				const reply = await worker.receive();
+				if (reply.type === "error") throw new Error(reply.message);
+				if (reply.type === "end") return;
+				if (reply.type !== "rows") throw new Error(`The parse worker answered ${reply.type} to a read`);
+				yield reply.rows;
+				worker.send({ type: "next" });
+			}
+		} finally {
+			worker.stop();
+		}
+	}
+});
+//#endregion
+export { workerSheetSource };