@chelone/core 0.5.0 → 0.7.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,37 @@
+/**
+ * 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;

package/dist/guards.js

@@ -0,0 +1,62 @@
+// 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());
+}
+/**
+* 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, 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 };