@chelone/core 0.6.0 → 0.9.0

package/dist/geo/snap-to-roads.js

@@ -1,52 +1,57 @@
-const OSRM_MAX_POSITIONS = 100;
+import { isRecord } from "../guards.js";
+import { isGeoGeometry } from "./geojson.js";
+// src/geo/snap-to-roads.ts
+/** The match service rejects a request with more coordinates than this; a longer line is matched in chunks. */
+var OSRM_MAX_POSITIONS = 100;
+/**
+* The line OSRM matched to one chunk, or `null` when the answer is not a
+* single LineString of finite coordinates it can hand back.
+*/
+function matchedLine(body) {
+	if (!isRecord(body) || body.code !== "Ok") return null;
+	if (!Array.isArray(body.matchings) || body.matchings.length !== 1) return null;
+	const matching = body.matchings[0];
+	if (!isRecord(matching)) return null;
+	const geometry = matching.geometry;
+	if (!isGeoGeometry(geometry) || geometry.type !== "LineString") return null;
+	return geometry.coordinates.length === 0 ? null : geometry.coordinates;
+}
 function createOsrmProvider(options) {
-  const { endpoint, profile = "driving" } = options;
-  if (typeof endpoint !== "string" || endpoint.trim() === "") {
-    throw new TypeError(
-      'createOsrmProvider: the "endpoint" option is required'
-    );
-  }
-  const base = endpoint.trim().replace(/\/+$/, "");
-  const doFetch = options.fetch ?? ((input, init) => globalThis.fetch(input, init));
-  async function matchChunk(positions, signal) {
-    const path = positions.map(([lng, lat]) => `${lng},${lat}`).join(";");
-    try {
-      const response = await doFetch(
-        `${base}/match/v1/${profile}/${path}?geometries=geojson&overview=full`,
-        { signal }
-      );
-      if (!response.ok) return null;
-      const body = await response.json();
-      if (body?.code !== "Ok") return null;
-      if (body.matchings?.length !== 1) return null;
-      const geometry = body.matchings[0]?.geometry;
-      if (geometry?.type !== "LineString" || !Array.isArray(geometry.coordinates) || geometry.coordinates.length === 0) {
-        return null;
-      }
-      return geometry.coordinates;
-    } catch (error) {
-      if (signal?.aborted) throw error;
-      return null;
-    }
-  }
-  return {
-    name: "osrm",
-    async snapToRoad(line, requestOptions = {}) {
-      const { signal } = requestOptions;
-      const positions = line.coordinates;
-      if (positions.length < 2) return null;
-      const joined = [];
-      for (let start = 0; start < positions.length - 1; ) {
-        const end = Math.min(start + OSRM_MAX_POSITIONS, positions.length);
-        const piece = await matchChunk(positions.slice(start, end), signal);
-        if (!piece) return null;
-        joined.push(...start === 0 ? piece : piece.slice(1));
-        start = end - 1;
-      }
-      return { type: "LineString", coordinates: joined };
-    }
-  };
+	const { endpoint, profile = "driving" } = options;
+	if (typeof endpoint !== "string" || endpoint.trim() === "") throw new TypeError("createOsrmProvider: the \"endpoint\" option is required");
+	const base = endpoint.trim().replace(/\/+$/, "");
+	const doFetch = options.fetch ?? ((input, init) => globalThis.fetch(input, init));
+	/** One match request; `null` when the server cannot match the chunk. */
+	async function matchChunk(positions, signal) {
+		const path = positions.map(([lng, lat]) => `${lng},${lat}`).join(";");
+		try {
+			const response = await doFetch(`${base}/match/v1/${profile}/${path}?geometries=geojson&overview=full`, { signal });
+			if (!response.ok) return null;
+			return matchedLine(await response.json());
+		} catch (error) {
+			if (signal?.aborted) throw error;
+			return null;
+		}
+	}
+	return {
+		name: "osrm",
+		async snapToRoad(line, requestOptions = {}) {
+			const { signal } = requestOptions;
+			const positions = line.coordinates;
+			if (positions.length < 2) return null;
+			const joined = [];
+			for (let start = 0; start < positions.length - 1;) {
+				const end = Math.min(start + OSRM_MAX_POSITIONS, positions.length);
+				const piece = await matchChunk(positions.slice(start, end), signal);
+				if (!piece) return null;
+				joined.push(...start === 0 ? piece : piece.slice(1));
+				start = end - 1;
+			}
+			return {
+				type: "LineString",
+				coordinates: joined
+			};
+		}
+	};
 }
-export {
-  createOsrmProvider
-};
+export { createOsrmProvider };

package/dist/geo/throttle.js

@@ -1,45 +1,42 @@
+// src/geo/throttle.ts
 function abortError() {
-  return new DOMException("Aborted", "AbortError");
+	return new DOMException("Aborted", "AbortError");
 }
 function timerSleep(ms, signal) {
-  return new Promise((resolve, reject) => {
-    if (signal?.aborted) return reject(abortError());
-    const onAbort = () => {
-      clearTimeout(timer);
-      reject(abortError());
-    };
-    const timer = setTimeout(() => {
-      signal?.removeEventListener("abort", onAbort);
-      resolve();
-    }, ms);
-    signal?.addEventListener("abort", onAbort, { once: true });
-  });
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) return reject(abortError());
+		const onAbort = () => {
+			clearTimeout(timer);
+			reject(abortError());
+		};
+		const timer = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
 }
 function createThrottle(options) {
-  const { minIntervalMs, now = Date.now, sleep = timerSleep } = options;
-  let nextAllowedAt = Number.NEGATIVE_INFINITY;
-  let tail = Promise.resolve();
-  const takeTurn = async (signal) => {
-    if (signal?.aborted) throw abortError();
-    const delay = nextAllowedAt - now();
-    if (delay > 0) await sleep(delay, signal);
-    if (signal?.aborted) throw abortError();
-    nextAllowedAt = now() + minIntervalMs;
-  };
-  return {
-    wait(signal) {
-      if (signal?.aborted) return Promise.reject(abortError());
-      const turn = tail.then(() => takeTurn(signal));
-      tail = turn.catch(() => void 0);
-      if (!signal) return turn;
-      return new Promise((resolve, reject) => {
-        const onAbort = () => reject(abortError());
-        signal.addEventListener("abort", onAbort, { once: true });
-        turn.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
-      });
-    }
-  };
+	const { minIntervalMs, now = Date.now, sleep = timerSleep } = options;
+	let nextAllowedAt = Number.NEGATIVE_INFINITY;
+	let tail = Promise.resolve();
+	const takeTurn = async (signal) => {
+		if (signal?.aborted) throw abortError();
+		const delay = nextAllowedAt - now();
+		if (delay > 0) await sleep(delay, signal);
+		if (signal?.aborted) throw abortError();
+		nextAllowedAt = now() + minIntervalMs;
+	};
+	return { wait(signal) {
+		if (signal?.aborted) return Promise.reject(abortError());
+		const turn = tail.then(() => takeTurn(signal));
+		tail = turn.catch(() => void 0);
+		if (!signal) return turn;
+		return new Promise((resolve, reject) => {
+			const onAbort = () => reject(abortError());
+			signal.addEventListener("abort", onAbort, { once: true });
+			turn.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
+		});
+	} };
 }
-export {
-  createThrottle
-};
+export { createThrottle };

package/dist/guards.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Core's object guards, in one place. Two questions, each answered once:
+ * `isRecord` — is it an object at all, so a Date, a Map and a class instance
+ * pass; `isPlainObject` — could a caller have written it as an object literal,
+ * which needs `Object.prototype` or `null` as its prototype. `isJsonObject`
+ * answers a third question, about what a value holds all the way down.
+ */
+/** What JSON can hold: the members of a parsed document. */
+export type JsonValue = string | number | boolean | null | JsonValue[] | JsonObject;
+/** An object whose every member is a JSON value. */
+export type JsonObject = {
+    [key: string]: JsonValue;
+};
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+/**
+ * Could `value` have been written as an object literal? Only
+ * `Object.prototype` or `null` as its prototype passes, so a Date, a Map and a
+ * class instance do not.
+ */
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+/**
+ * An object that holds `key`, so `value[key]` reads without a cast. The
+ * member's type is `unknown`: the guard proves it is there, not what it is.
+ */
+export declare function hasProperty<TKey extends string>(value: unknown, key: TKey): value is Record<TKey, unknown>;
+/**
+ * Could `await value` wait on it? A promise, or any object with a `then`
+ * function. A bare function is refused even when it has no `then`.
+ */
+export declare function isThenable(value: unknown): value is PromiseLike<unknown>;
+/**
+ * True when `value` is an object JSON could have produced: plain objects and
+ * arrays down to strings, finite numbers, booleans and null. `NaN` and
+ * `Infinity` are refused, because `JSON.stringify` turns them into `null`, and
+ * so is a value that contains itself.
+ */
+export declare function isJsonObject(value: unknown): value is JsonObject;
+/**
+ * Could `new Headers(value)` take it? A `Headers`, a list of `[name, value]`
+ * pairs, or a record whose every value is a string. A pair list holding a
+ * non-string, and a record holding a number or a null, are refused: `Headers`
+ * would read them as names and values it was never given.
+ */
+export declare function isHeadersInit(value: unknown): value is HeadersInit;

package/dist/guards.js

@@ -0,0 +1,77 @@
+// src/guards.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Could `value` have been written as an object literal? Only
+* `Object.prototype` or `null` as its prototype passes, so a Date, a Map and a
+* class instance do not.
+*/
+function isPlainObject(value) {
+	if (!isRecord(value)) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+/**
+* An object that holds `key`, so `value[key]` reads without a cast. The
+* member's type is `unknown`: the guard proves it is there, not what it is.
+*/
+function hasProperty(value, key) {
+	return isRecord(value) && key in value;
+}
+/**
+* Could `await value` wait on it? A promise, or any object with a `then`
+* function. A bare function is refused even when it has no `then`.
+*/
+function isThenable(value) {
+	return hasProperty(value, "then") && typeof value.then === "function";
+}
+/**
+* True when `value` is an object JSON could have produced: plain objects and
+* arrays down to strings, finite numbers, booleans and null. `NaN` and
+* `Infinity` are refused, because `JSON.stringify` turns them into `null`, and
+* so is a value that contains itself.
+*/
+function isJsonObject(value) {
+	return isPlainObject(value) && isJsonValue(value, /* @__PURE__ */ new WeakSet());
+}
+/**
+* Could `new Headers(value)` take it? A `Headers`, a list of `[name, value]`
+* pairs, or a record whose every value is a string. A pair list holding a
+* non-string, and a record holding a number or a null, are refused: `Headers`
+* would read them as names and values it was never given.
+*/
+function isHeadersInit(value) {
+	if (value instanceof Headers) return true;
+	if (Array.isArray(value)) return value.every(isHeaderPair);
+	return isPlainObject(value) && Object.values(value).every((entry) => typeof entry === "string");
+}
+/** One `[name, value]` header pair. A longer or shorter array is not one. */
+function isHeaderPair(value) {
+	return Array.isArray(value) && value.length === 2 && typeof value[0] === "string" && typeof value[1] === "string";
+}
+/**
+* The deep half of `isJsonObject`. `path` holds the containers `value` sits
+* inside, so a value that contains itself is refused instead of walked
+* forever; a shared sub-object, which no container holds twice on one path,
+* still passes.
+*/
+function isJsonValue(value, path) {
+	if (value === null) return true;
+	if (typeof value === "string" || typeof value === "boolean") return true;
+	if (typeof value === "number") return Number.isFinite(value);
+	if (Array.isArray(value)) {
+		if (path.has(value)) return false;
+		path.add(value);
+		const held = value.every((item) => isJsonValue(item, path));
+		path.delete(value);
+		return held;
+	}
+	if (!isPlainObject(value)) return false;
+	if (path.has(value)) return false;
+	path.add(value);
+	const held = Object.values(value).every((item) => isJsonValue(item, path));
+	path.delete(value);
+	return held;
+}
+export { hasProperty, isHeadersInit, isJsonObject, isPlainObject, isRecord, isThenable };

package/dist/i18n/default-messages.js

@@ -1,31 +1,36 @@
 import { defineMessages } from "./messages.js";
-const defaultMessages = defineMessages({
-  "chelone.auth.auth_check_error": "Please login to continue",
-  "chelone.auth.logout": "Logout",
-  "chelone.message.access_denied": "You don't have access to this page",
-  "chelone.message.authentication_error": "The authentication server returned an error",
-  "chelone.message.invalid_form": "The form is not valid. Please check for errors",
-  "chelone.message.loading": "The page is loading, just a moment please",
-  "chelone.message.not_found": "Either you typed a wrong URL, or you followed a bad link.",
-  "chelone.message.select_all_limit_reached": "There are too many elements to select them all. Only the first {max} elements were selected",
-  "chelone.message.unsaved_changes": "Some of your changes weren't saved. Are you sure you want to ignore them?",
-  "chelone.notification.created": "Element created",
-  "chelone.notification.deleted": "Element deleted",
-  "chelone.notification.http_error": "Server communication error",
-  "chelone.notification.item_doesnt_exist": "Element does not exist",
-  "chelone.notification.logged_out": "Your session has ended, please reconnect",
-  "chelone.notification.not_authorized": "You are not authorized to access this resource",
-  "chelone.notification.updated": "Element updated",
-  "chelone.validation.email": "Must be a valid email",
-  "chelone.validation.maxLength": "Must be {max} characters or less",
-  "chelone.validation.maxValue": "Must be {max} or less",
-  "chelone.validation.minLength": "Must be {min} characters at least",
-  "chelone.validation.minValue": "Must be at least {min}",
-  "chelone.validation.number": "Must be a number",
-  "chelone.validation.oneOf": "Must be one of: {options}",
-  "chelone.validation.regex": "Must match a specific format (regexp): {pattern}",
-  "chelone.validation.required": "Required"
+// src/i18n/default-messages.ts
+/**
+* English defaults for every i18n key the core controllers emit. Apps merge
+* these under their own catalogs (`{ ...defaultMessages, ...appMessages }`);
+* resource-scoped keys (`resources.{name}.notifications.{event}`) override
+* them through the translate-fallback pattern.
+*/
+var defaultMessages = defineMessages({
+	"chelone.auth.auth_check_error": "Please login to continue",
+	"chelone.auth.logout": "Logout",
+	"chelone.message.access_denied": "You don't have access to this page",
+	"chelone.message.authentication_error": "The authentication server returned an error",
+	"chelone.message.invalid_form": "The form is not valid. Please check for errors",
+	"chelone.message.loading": "The page is loading, just a moment please",
+	"chelone.message.not_found": "Either you typed a wrong URL, or you followed a bad link.",
+	"chelone.message.select_all_limit_reached": "There are too many elements to select them all. Only the first {max} elements were selected",
+	"chelone.message.unsaved_changes": "Some of your changes weren't saved. Are you sure you want to ignore them?",
+	"chelone.notification.created": "Element created",
+	"chelone.notification.deleted": "Element deleted",
+	"chelone.notification.http_error": "Server communication error",
+	"chelone.notification.item_doesnt_exist": "Element does not exist",
+	"chelone.notification.logged_out": "Your session has ended, please reconnect",
+	"chelone.notification.not_authorized": "You are not authorized to access this resource",
+	"chelone.notification.updated": "Element updated",
+	"chelone.validation.email": "Must be a valid email",
+	"chelone.validation.maxLength": "Must be {max} characters or less",
+	"chelone.validation.maxValue": "Must be {max} or less",
+	"chelone.validation.minLength": "Must be {min} characters at least",
+	"chelone.validation.minValue": "Must be at least {min}",
+	"chelone.validation.number": "Must be a number",
+	"chelone.validation.oneOf": "Must be one of: {options}",
+	"chelone.validation.regex": "Must match a specific format (regexp): {pattern}",
+	"chelone.validation.required": "Required"
 });
-export {
-  defaultMessages
-};
+export { defaultMessages };

package/dist/i18n/english-messages.d.ts

@@ -181,6 +181,178 @@ export declare const englishMessages: {
     readonly "ra.saved_queries.new_label": "Save current query";
     readonly "ra.saved_queries.query_name": "Query name";
     readonly "ra.saved_queries.remove_label_with_name": "Remove saved query \"{name}\"";
+    readonly "chelone.assistant.close": "Close";
+    readonly "chelone.assistant.confirm": "Run {name}?";
+    readonly "chelone.assistant.error": "Something went wrong.";
+    readonly "chelone.assistant.placeholder": "Ask…";
+    readonly "chelone.assistant.retry": "Retry";
+    readonly "chelone.assistant.send": "Send";
+    readonly "chelone.assistant.stop": "Stop";
+    readonly "chelone.assistant.thinking": "Thinking…";
+    readonly "chelone.assistant.trigger": "Ask";
+    readonly "chelone.assistant.welcome": "Hi! Ask me anything.";
+    readonly "chelone.approval.already_approved": "You already approved";
+    readonly "chelone.approval.approve": "Approve";
+    readonly "chelone.approval.complete": "Fully approved ({count} of {required})";
+    readonly "chelone.approval.count": "{count} of {required}";
+    readonly "chelone.approval.fully_approved": "Fully approved ({count} of {required})";
+    readonly "chelone.approval.reject": "Reject";
+    readonly "chelone.approval_queue.confirm_reject": "Confirm reject";
+    readonly "chelone.approval_queue.empty": "No items waiting for approval";
+    readonly "chelone.approval_queue.reason": "Reason";
+    readonly "chelone.approval_queue.rejected": "Rejected";
+    readonly "chelone.block_editor.add_block": "Add block";
+    readonly "chelone.block_editor.chart.aggregate": "Aggregate";
+    readonly "chelone.block_editor.chart.avg": "Average";
+    readonly "chelone.block_editor.chart.bar": "Bar";
+    readonly "chelone.block_editor.chart.category": "Category field";
+    readonly "chelone.block_editor.chart.count": "Count";
+    readonly "chelone.block_editor.chart.description": "Aggregate a resource into a chart";
+    readonly "chelone.block_editor.chart.label": "Chart";
+    readonly "chelone.block_editor.chart.line": "Line";
+    readonly "chelone.block_editor.chart.pie": "Pie";
+    readonly "chelone.block_editor.chart.sum": "Sum";
+    readonly "chelone.block_editor.chart.type": "Chart type";
+    readonly "chelone.block_editor.chart.value": "Value field";
+    readonly "chelone.block_editor.data.choose_resource": "Choose a resource";
+    readonly "chelone.block_editor.data.fields": "Fields";
+    readonly "chelone.block_editor.data.fields_hint": "title, status";
+    readonly "chelone.block_editor.data.resource": "Resource";
+    readonly "chelone.block_editor.drag": "Drag to move";
+    readonly "chelone.block_editor.embed.empty": "Add a YouTube or Vimeo link";
+    readonly "chelone.block_editor.embed.title": "Embedded video";
+    readonly "chelone.block_editor.image.alt": "Alt text";
+    readonly "chelone.block_editor.image.empty": "Add an image";
+    readonly "chelone.block_editor.image.too_large": "Choose an image file up to 5 MB";
+    readonly "chelone.block_editor.image.upload": "Upload image";
+    readonly "chelone.block_editor.image.url": "Image URL";
+    readonly "chelone.block_editor.image.width": "Width (%)";
+    readonly "chelone.block_editor.no_blocks": "No blocks found";
+    readonly "chelone.block_editor.placeholder": "Type / for blocks";
+    readonly "chelone.block_editor.recordList.description": "Embed a live list from a resource";
+    readonly "chelone.block_editor.recordList.label": "Record list";
+    readonly "chelone.block_editor.recordList.no_records": "No records";
+    readonly "chelone.block_editor.recordList.per_page": "Rows";
+    readonly "chelone.block_editor.referenceRecord.card": "Card";
+    readonly "chelone.block_editor.referenceRecord.description": "Embed a live record";
+    readonly "chelone.block_editor.referenceRecord.id": "Record id";
+    readonly "chelone.block_editor.referenceRecord.inline": "Inline";
+    readonly "chelone.block_editor.referenceRecord.label": "Reference record";
+    readonly "chelone.block_editor.referenceRecord.layout": "Layout";
+    readonly "chelone.block_editor.search": "Search blocks";
+    readonly "chelone.block_editor.toolbar.configure": "Configure";
+    readonly "chelone.block_editor.toolbar.delete": "Delete";
+    readonly "chelone.block_editor.toolbar.duplicate": "Duplicate";
+    readonly "chelone.block_editor.toolbar.label": "Block actions";
+    readonly "chelone.block_editor.toolbar.move_down": "Move down";
+    readonly "chelone.block_editor.toolbar.move_up": "Move up";
+    readonly "chelone.block_editor.unknown": "Unknown block: {type}. It is kept on save.";
+    readonly "chelone.chart.empty": "No data";
+    readonly "chelone.command_menu.account": "Account";
+    readonly "chelone.command_menu.action.logout": "Log out";
+    readonly "chelone.command_menu.action.refresh": "Refresh data";
+    readonly "chelone.command_menu.action.theme_dark": "Switch to dark theme";
+    readonly "chelone.command_menu.action.theme_light": "Switch to light theme";
+    readonly "chelone.command_menu.action.theme_system": "Use system theme";
+    readonly "chelone.command_menu.actions": "Actions";
+    readonly "chelone.command_menu.close": "Close";
+    readonly "chelone.command_menu.description": "Jump to a page or record, or run an action.";
+    readonly "chelone.command_menu.empty": "No results found.";
+    readonly "chelone.command_menu.footer.close": "Close";
+    readonly "chelone.command_menu.footer.navigate": "Navigate";
+    readonly "chelone.command_menu.footer.select": "Select";
+    readonly "chelone.command_menu.navigate": "Navigate";
+    readonly "chelone.command_menu.placeholder": "Search or run a command...";
+    readonly "chelone.command_menu.recent": "Recent";
+    readonly "chelone.command_menu.refresh": "Refresh";
+    readonly "chelone.command_menu.resources": "Resources";
+    readonly "chelone.command_menu.select": "Select";
+    readonly "chelone.command_menu.theme": "Theme";
+    readonly "chelone.command_menu.title": "Command menu";
+    readonly "chelone.comments.anonymous": "anonymous";
+    readonly "chelone.comments.empty": "No comments yet. Be the first.";
+    readonly "chelone.comments.load_failed": "Could not load the comments";
+    readonly "chelone.comments.mark_resolved": "Mark resolved";
+    readonly "chelone.comments.placeholder": "Write a comment…";
+    readonly "chelone.comments.post": "Post";
+    readonly "chelone.comments.resolved": "Resolved {time}";
+    readonly "chelone.comments.showing": "Showing the first {shown} of {total} comments";
+    readonly "chelone.comments.showing_first": "Showing the first {shown} of {total} comments";
+    readonly "chelone.devtools.clear": "Clear";
+    readonly "chelone.devtools.details": "Details";
+    readonly "chelone.devtools.empty": "No calls yet";
+    readonly "chelone.devtools.hide": "Hide";
+    readonly "chelone.devtools.params": "Params";
+    readonly "chelone.devtools.result": "Result";
+    readonly "chelone.devtools.show": "Show";
+    readonly "chelone.devtools.title": "Data provider";
+    readonly "chelone.diff_viewer.after": "After";
+    readonly "chelone.diff_viewer.before": "Before";
+    readonly "chelone.diff_viewer.empty": "(empty)";
+    readonly "chelone.diff_viewer.field": "Field";
+    readonly "chelone.guesser.no_schema.message": "Register a Zod schema for {resource} with defineResources so this page can be generated.";
+    readonly "chelone.guesser.no_schema.title": "No schema registered";
+    readonly "chelone.i18n_key_editor.copied": "Copied";
+    readonly "chelone.i18n_key_editor.copy_failed": "Could not copy the translations";
+    readonly "chelone.i18n_key_editor.empty": "No missing keys yet";
+    readonly "chelone.i18n_key_editor.export": "Export";
+    readonly "chelone.i18n_key_editor.hide": "Hide";
+    readonly "chelone.i18n_key_editor.show": "Show";
+    readonly "chelone.i18n_key_editor.title": "Missing keys ({count})";
+    readonly "chelone.inspector.configure_mode": "Configure mode";
+    readonly "chelone.inspector.customize": "Customize";
+    readonly "chelone.inspector.drag_field": "Drag to reorder";
+    readonly "chelone.inspector.empty": "Pick an outlined element to configure it";
+    readonly "chelone.inspector.inputs_title": "Form";
+    readonly "chelone.inspector.title": "Inspector";
+    readonly "chelone.job_monitor.attempts": "Attempts: {attempts}";
+    readonly "chelone.job_monitor.empty": "No {status} jobs";
+    readonly "chelone.job_monitor.hide_payload": "Hide payload";
+    readonly "chelone.job_monitor.no_type": "(no type)";
+    readonly "chelone.job_monitor.retry": "Retry";
+    readonly "chelone.job_monitor.show_payload": "Show payload";
+    readonly "chelone.job_monitor.title": "Jobs";
+    readonly "chelone.kanban_board.empty": "No items";
+    readonly "chelone.kanban_board.move": "Move {title}";
+    readonly "chelone.lock.locked_by": "Locked by {identity}";
+    readonly "chelone.navigation.load_more": "Load more";
+    readonly "chelone.navigation.no_more_rows": "No more rows";
+    readonly "chelone.onboarding_tour.back": "Back";
+    readonly "chelone.onboarding_tour.finish": "Finish";
+    readonly "chelone.onboarding_tour.next": "Next";
+    readonly "chelone.onboarding_tour.skip": "Skip";
+    readonly "chelone.permission_matrix.all": "All";
+    readonly "chelone.permission_matrix.cell": "{role} {action} {resource}";
+    readonly "chelone.permission_matrix.inherited": "Granted by a wildcard";
+    readonly "chelone.permission_matrix.no_roles": "No roles defined";
+    readonly "chelone.permission_matrix.resource": "Resource";
+    readonly "chelone.pivot_grid.no_value": "(none)";
+    readonly "chelone.pivot_grid.total": "Total";
+    readonly "chelone.record_timeline.empty": "No activity yet";
+    readonly "chelone.rich_text.block_type": "Block type";
+    readonly "chelone.rich_text.color": "Text color";
+    readonly "chelone.rich_text.image": "Image";
+    readonly "chelone.rich_text.image.close": "Close";
+    readonly "chelone.rich_text.image.error": "The image could not be loaded";
+    readonly "chelone.rich_text.image.resize_left": "Resize image from the left edge";
+    readonly "chelone.rich_text.image.resize_right": "Resize image from the right edge";
+    readonly "chelone.rich_text.image.uploading": "Uploading image";
+    readonly "chelone.rich_text.image.view": "View image";
+    readonly "chelone.rich_text.image_apply": "Apply";
+    readonly "chelone.rich_text.image_upload": "Upload";
+    readonly "chelone.rich_text.image_url": "Image URL";
+    readonly "chelone.rich_text.invalid_image_url": "Enter a link to an image";
+    readonly "chelone.rich_text.invalid_url": "Enter a web, mail or phone link";
+    readonly "chelone.rich_text.link_apply": "Apply";
+    readonly "chelone.rich_text.link_remove": "Remove";
+    readonly "chelone.rich_text.link_url": "URL";
+    readonly "chelone.rich_text.paragraph": "Paragraph";
+    readonly "chelone.rich_text.toolbar": "Formatting";
+    readonly "chelone.action.format": "Format";
+    readonly "chelone.status_transition.change": "Change status";
+    readonly "chelone.status_transition.confirm_content": "Move to {status}?";
+    readonly "chelone.status_transition.confirm_title": "Change status?";
+    readonly "chelone.validation.invalid_json": "Invalid JSON: {message}";
     readonly "chelone.map.load_failed": "The map could not be loaded";
     readonly "chelone.map.no_coordinates": "No coordinates";
     readonly "chelone.map.no_geometry": "No geometry";