@chelone/core 0.6.0 → 0.9.0

package/dist/i18n/i18n.js

@@ -1,68 +1,55 @@
+// src/i18n/i18n.ts
 function interpolate(template, params) {
-  if (!params) return template;
-  return template.replace(
-    /\{(\w+)\}/g,
-    (match, name) => name in params ? String(params[name]) : match
-  );
+	if (!params) return template;
+	return template.replace(/\{(\w+)\}/g, (match, name) => name in params ? String(params[name]) : match);
 }
 function resolve(value, locale, params) {
-  if (typeof value === "string") return interpolate(value, params);
-  const raw = params?.count ?? params?.smart_count;
-  const count = typeof raw === "number" ? raw : Number(raw ?? Number.NaN);
-  if (Number.isNaN(count)) return interpolate(value.other, params);
-  const category = new Intl.PluralRules(locale).select(count);
-  return interpolate(value[category] ?? value.other, {
-    ...params,
-    count: params?.count ?? raw,
-    smart_count: params?.smart_count ?? raw
-  });
+	if (typeof value === "string") return interpolate(value, params);
+	const raw = params?.count ?? params?.smart_count;
+	if (raw === void 0 || raw === null) return interpolate(value.other, params);
+	const count = Number(raw);
+	if (Number.isNaN(count)) return interpolate(value.other, params);
+	return interpolate(value[new Intl.PluralRules(locale).select(count)] ?? value.other, {
+		...params,
+		count: params?.count ?? raw,
+		smart_count: params?.smart_count ?? raw
+	});
 }
+/** Own-property lookup: `"constructor"` or `"toString"` is a missing key, not a function. */
 function lookup(catalog, key) {
-  return catalog && Object.hasOwn(catalog, key) ? catalog[key] : void 0;
+	return catalog && Object.hasOwn(catalog, key) ? catalog[key] : void 0;
 }
 function createI18n(options) {
-  let locale = options.locale;
-  const subscribers = /* @__PURE__ */ new Set();
-  return {
-    translate(key, ...args) {
-      const params = args[0];
-      const own = lookup(options.messages[locale], key);
-      if (own === void 0 && options.onMissingKey) {
-        try {
-          options.onMissingKey(
-            key,
-            locale,
-            typeof params?._ === "string" ? params._ : void 0
-          );
-        } catch (error) {
-          console.error(error);
-        }
-      }
-      const value = own ?? (options.fallbackLocale ? lookup(options.messages[options.fallbackLocale], key) : void 0);
-      if (value === void 0) {
-        if (typeof params?._ === "string") return interpolate(params._, params);
-        return key;
-      }
-      return resolve(value, locale, params);
-    },
-    getLocale: () => locale,
-    setLocale(next) {
-      if (!Object.hasOwn(options.messages, next)) {
-        throw new Error(
-          `createI18n: unknown locale "${next}" — available: ${Object.keys(options.messages).join(", ")}`
-        );
-      }
-      if (next === locale) return;
-      locale = next;
-      for (const cb of subscribers) cb();
-    },
-    getLocales: () => Object.keys(options.messages),
-    subscribe(callback) {
-      subscribers.add(callback);
-      return () => void subscribers.delete(callback);
-    }
-  };
+	let locale = options.locale;
+	const subscribers = /* @__PURE__ */ new Set();
+	return {
+		translate(key, ...args) {
+			const params = args[0];
+			const own = lookup(options.messages[locale], key);
+			if (own === void 0 && options.onMissingKey) try {
+				options.onMissingKey(key, locale, typeof params?._ === "string" ? params._ : void 0);
+			} catch (error) {
+				console.error(error);
+			}
+			const value = own ?? (options.fallbackLocale ? lookup(options.messages[options.fallbackLocale], key) : void 0);
+			if (value === void 0) {
+				if (typeof params?._ === "string") return interpolate(params._, params);
+				return key;
+			}
+			return resolve(value, locale, params);
+		},
+		getLocale: () => locale,
+		setLocale(next) {
+			if (!Object.hasOwn(options.messages, next)) throw new Error(`createI18n: unknown locale "${next}" — available: ${Object.keys(options.messages).join(", ")}`);
+			if (next === locale) return;
+			locale = next;
+			for (const cb of subscribers) cb();
+		},
+		getLocales: () => Object.keys(options.messages),
+		subscribe(callback) {
+			subscribers.add(callback);
+			return () => void subscribers.delete(callback);
+		}
+	};
 }
-export {
-  createI18n
-};
+export { createI18n };

package/dist/i18n/inflection.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Clean-room reimplementation of the SUBSET of the `inflection` package the
+ * ra-core label helpers rely on. Chelone carries no `inflection` dependency, so
+ * these three small helpers cover exactly what `useGetResourceLabel` /
+ * `useTranslateLabel` need:
+ *
+ * - `humanize(text)` — ra-core `humanize`: strip a trailing `_id`, replace
+ *   underscores with spaces, lowercase, and capitalize the first letter. Does
+ *   NOT split camelCase (parity: `humanize('authorName') === 'Authorname'`).
+ * - `humanizeField(source)` — ra-core `transform(['underscore','humanize'])`:
+ *   camelCase-aware, so `firstName` → `First name`. Used for field labels.
+ * - `pluralize(word, count)` — ra-core `inflect(word, count)`: singular for
+ *   `count === 1`, plural otherwise. Covers the regular English rules plus a
+ *   small irregular set. Full parity with `inflection`'s complete irregular
+ *   table is a documented non-goal (the fallback only fires when a translation
+ *   key AND an `options.label` are both absent).
+ */
+/**
+ * ra-core `humanize`: strip a trailing `_id`, underscores → spaces, lowercase,
+ * capitalize the first letter. Deliberately does NOT split camelCase.
+ */
+export declare function humanize(text: string): string;
+/**
+ * ra-core `transform(source, ['underscore','humanize'])`: camelCase-aware
+ * humanization for field labels. `firstName` → `First name`, `full_name` →
+ * `Full name`, `author name` → `Author name`.
+ */
+export declare function humanizeField(source: string): string;
+/**
+ * ra-core `inflect(word, count)`: singularize when `count === 1`, pluralize
+ * otherwise. Case-preserving only for the first letter (the caller humanizes
+ * afterward, so casing beyond that does not matter here).
+ */
+export declare function pluralize(word: string, count?: number): string;

package/dist/i18n/inflection.js

@@ -0,0 +1,82 @@
+// src/i18n/inflection.ts
+/**
+* Clean-room reimplementation of the SUBSET of the `inflection` package the
+* ra-core label helpers rely on. Chelone carries no `inflection` dependency, so
+* these three small helpers cover exactly what `useGetResourceLabel` /
+* `useTranslateLabel` need:
+*
+* - `humanize(text)` — ra-core `humanize`: strip a trailing `_id`, replace
+*   underscores with spaces, lowercase, and capitalize the first letter. Does
+*   NOT split camelCase (parity: `humanize('authorName') === 'Authorname'`).
+* - `humanizeField(source)` — ra-core `transform(['underscore','humanize'])`:
+*   camelCase-aware, so `firstName` → `First name`. Used for field labels.
+* - `pluralize(word, count)` — ra-core `inflect(word, count)`: singular for
+*   `count === 1`, plural otherwise. Covers the regular English rules plus a
+*   small irregular set. Full parity with `inflection`'s complete irregular
+*   table is a documented non-goal (the fallback only fires when a translation
+*   key AND an `options.label` are both absent).
+*/
+/** Capitalize the first character; leave the rest untouched. */
+function capitalizeFirst(text) {
+	return text.length === 0 ? text : text.charAt(0).toUpperCase() + text.slice(1);
+}
+/**
+* Convert a camelCase / snake_case identifier to lowercase underscore form:
+* `firstName` → `first_name`, `full_name` → `full_name`.
+*/
+function underscore(text) {
+	return text.replace(/([a-z\d])([A-Z])/g, "$1_$2").replace(/[-\s]+/g, "_").toLowerCase();
+}
+/**
+* ra-core `humanize`: strip a trailing `_id`, underscores → spaces, lowercase,
+* capitalize the first letter. Deliberately does NOT split camelCase.
+*/
+function humanize(text) {
+	return capitalizeFirst(text.replace(/_id$/, "").replace(/_+/g, " ").trim().toLowerCase());
+}
+/**
+* ra-core `transform(source, ['underscore','humanize'])`: camelCase-aware
+* humanization for field labels. `firstName` → `First name`, `full_name` →
+* `Full name`, `author name` → `Author name`.
+*/
+function humanizeField(source) {
+	return humanize(underscore(source));
+}
+var IRREGULARS = [
+	["person", "people"],
+	["child", "children"],
+	["man", "men"],
+	["woman", "women"],
+	["mouse", "mice"],
+	["foot", "feet"],
+	["tooth", "teeth"],
+	["goose", "geese"]
+];
+/** Regular English plural of a lowercase word (idempotent on plurals). */
+function toPlural(word) {
+	for (const [singular, plural] of IRREGULARS) if (word === singular || word === plural) return plural;
+	const singular = toSingular(word);
+	if (/[^aeiou]y$/.test(singular)) return `${singular.slice(0, -1)}ies`;
+	if (/(s|x|z|ch|sh)$/.test(singular)) return `${singular}es`;
+	return `${singular}s`;
+}
+/** Regular English singular of a lowercase word. */
+function toSingular(word) {
+	for (const [singular, plural] of IRREGULARS) {
+		if (word === plural) return singular;
+		if (word === singular) return singular;
+	}
+	if (/ies$/.test(word)) return `${word.slice(0, -3)}y`;
+	if (/(ss|x|z|ch|sh)es$/.test(word)) return word.slice(0, -2);
+	if (/s$/.test(word) && !/ss$/.test(word)) return word.slice(0, -1);
+	return word;
+}
+/**
+* ra-core `inflect(word, count)`: singularize when `count === 1`, pluralize
+* otherwise. Case-preserving only for the first letter (the caller humanizes
+* afterward, so casing beyond that does not matter here).
+*/
+function pluralize(word, count = 2) {
+	return count === 1 ? toSingular(word) : toPlural(word);
+}
+export { humanize, humanizeField, pluralize };

package/dist/i18n/messages.d.ts

@@ -4,6 +4,12 @@ export type PluralMessage = Partial<Record<Intl.LDMLPluralRule, string>> & {
 };
 export type MessageValue = string | PluralMessage;
 export type MessageCatalog = Record<string, MessageValue>;
+/** The values a message placeholder takes; one type for typed catalogs and the erased view. */
+export type TranslateParamValues = Record<string, string | number>;
+/** Boundary narrowing for `unknown` input: keeps the string and number entries of a plain object, `undefined` for anything else. */
+export declare function pickTranslateParamValues(value: unknown): TranslateParamValues | undefined;
+/** Drops absent values: an `undefined` param would otherwise render as the text "undefined". */
+export declare function definedParams(params: Record<string, string | number | undefined>): TranslateParamValues;
 /** Identity helper pinning literal keys AND literal template strings (for param inference). */
 export declare function defineMessages<const T extends MessageCatalog>(catalog: T): T;
 export type MessageKey<TCatalog extends MessageCatalog> = keyof TCatalog & string;
@@ -16,9 +22,11 @@ type ParamsObject<T extends string> = [ExtractParams<T>] extends [never] ? undef
  * Required params for a message value: placeholder names for plain strings;
  * plural messages additionally require `count` (drives Intl.PluralRules).
  */
-export type TranslateParams<TValue extends MessageValue> = TValue extends string ? ParamsObject<TValue> : TValue extends PluralMessage ? ([ExtractParams<TValue["other"]>] extends [never] ? unknown : {
+export type TranslateParams<TValue extends MessageValue> = TValue extends string ? ParamsObject<TValue> : TValue extends PluralMessage ? [ExtractParams<TValue["other"]>] extends [never] ? {
+    count: number;
+} : {
     [K in ExtractParams<TValue["other"]>]: string | number;
-}) & {
+} & {
     count: number;
 } : never;
 export {};

package/dist/i18n/messages.js

@@ -1,6 +1,19 @@
+// src/i18n/messages.ts
+/** Boundary narrowing for `unknown` input: keeps the string and number entries of a plain object, `undefined` for anything else. */
+function pickTranslateParamValues(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return;
+	const picked = {};
+	for (const [name, entry] of Object.entries(value)) if (typeof entry === "string" || typeof entry === "number") picked[name] = entry;
+	return picked;
+}
+/** Drops absent values: an `undefined` param would otherwise render as the text "undefined". */
+function definedParams(params) {
+	const defined = {};
+	for (const [name, value] of Object.entries(params)) if (value !== void 0) defined[name] = value;
+	return defined;
+}
+/** Identity helper pinning literal keys AND literal template strings (for param inference). */
 function defineMessages(catalog) {
-  return catalog;
+	return catalog;
 }
-export {
-  defineMessages
-};
+export { defineMessages, definedParams, pickTranslateParamValues };

package/dist/i18n/missing-keys.d.ts

@@ -1,3 +1,7 @@
+/** Every key the i18n key editor labels itself with. The panel never lists these. */
+export declare const OWN_KEY_PREFIX = "chelone.i18n_key_editor.";
+/** How long its export button shows `Copied`. */
+export declare const COPIED_MS = 1500;
 export interface MissingKeyEntry {
     key: string;
     fallback: string | undefined;

package/dist/i18n/missing-keys.js

@@ -1,64 +1,72 @@
-const NO_ENTRIES = [];
+// src/i18n/missing-keys.ts
+/** Every key the i18n key editor labels itself with. The panel never lists these. */
+var OWN_KEY_PREFIX = "chelone.i18n_key_editor.";
+/** How long its export button shows `Copied`. */
+var COPIED_MS = 1500;
+var NO_ENTRIES = [];
 function createMissingKeyStore() {
-  const byLocale = /* @__PURE__ */ new Map();
-  const snapshots = /* @__PURE__ */ new Map();
-  const subscribers = /* @__PURE__ */ new Set();
-  let scheduled = false;
-  const changed = (locale) => {
-    snapshots.delete(locale);
-    if (scheduled) return;
-    scheduled = true;
-    queueMicrotask(() => {
-      scheduled = false;
-      for (const cb of [...subscribers]) cb();
-    });
-  };
-  const getEntries = (locale) => {
-    const cached = snapshots.get(locale);
-    if (cached) return cached;
-    const entries = byLocale.get(locale);
-    if (!entries?.size) return NO_ENTRIES;
-    const snapshot = [...entries.values()];
-    snapshots.set(locale, snapshot);
-    return snapshot;
-  };
-  return {
-    record(key, locale, fallback) {
-      let entries = byLocale.get(locale);
-      if (!entries) {
-        entries = /* @__PURE__ */ new Map();
-        byLocale.set(locale, entries);
-      }
-      if (entries.has(key)) return;
-      entries.set(key, { key, fallback, translation: "" });
-      changed(locale);
-    },
-    getEntries,
-    setTranslation(locale, key, text) {
-      const entries = byLocale.get(locale);
-      const entry = entries?.get(key);
-      if (!entries || !entry || entry.translation === text) return;
-      entries.set(key, { ...entry, translation: text });
-      changed(locale);
-    },
-    clear(locale) {
-      if (!byLocale.get(locale)?.size) return;
-      byLocale.delete(locale);
-      changed(locale);
-    },
-    toJson(locale) {
-      const out = /* @__PURE__ */ new Map();
-      for (const { key, translation } of getEntries(locale)) {
-        if (translation.trim() !== "") out.set(key, translation);
-      }
-      return JSON.stringify(Object.fromEntries(out), null, 2);
-    },
-    subscribe(callback) {
-      subscribers.add(callback);
-      return () => void subscribers.delete(callback);
-    }
-  };
+	const byLocale = /* @__PURE__ */ new Map();
+	const snapshots = /* @__PURE__ */ new Map();
+	const subscribers = /* @__PURE__ */ new Set();
+	let scheduled = false;
+	const changed = (locale) => {
+		snapshots.delete(locale);
+		if (scheduled) return;
+		scheduled = true;
+		queueMicrotask(() => {
+			scheduled = false;
+			for (const cb of [...subscribers]) cb();
+		});
+	};
+	const getEntries = (locale) => {
+		const cached = snapshots.get(locale);
+		if (cached) return cached;
+		const entries = byLocale.get(locale);
+		if (!entries?.size) return NO_ENTRIES;
+		const snapshot = [...entries.values()];
+		snapshots.set(locale, snapshot);
+		return snapshot;
+	};
+	return {
+		record(key, locale, fallback) {
+			let entries = byLocale.get(locale);
+			if (!entries) {
+				entries = /* @__PURE__ */ new Map();
+				byLocale.set(locale, entries);
+			}
+			if (entries.has(key)) return;
+			entries.set(key, {
+				key,
+				fallback,
+				translation: ""
+			});
+			changed(locale);
+		},
+		getEntries,
+		setTranslation(locale, key, text) {
+			const entries = byLocale.get(locale);
+			const entry = entries?.get(key);
+			if (!entries || !entry || entry.translation === text) return;
+			entries.set(key, {
+				...entry,
+				translation: text
+			});
+			changed(locale);
+		},
+		clear(locale) {
+			if (!byLocale.get(locale)?.size) return;
+			byLocale.delete(locale);
+			changed(locale);
+		},
+		toJson(locale) {
+			const out = /* @__PURE__ */ new Map();
+			for (const { key, translation } of getEntries(locale)) if (translation.trim() !== "") out.set(key, translation);
+			return JSON.stringify(Object.fromEntries(out), null, 2);
+		},
+		subscribe(callback) {
+			subscribers.add(callback);
+			return () => void subscribers.delete(callback);
+		}
+	};
 }
-export {
-  createMissingKeyStore
-};
+export { COPIED_MS, OWN_KEY_PREFIX, createMissingKeyStore };

package/dist/i18n/translatable.d.ts

@@ -19,6 +19,20 @@ export interface TranslatableController {
  * form values themselves stay in the form; this only tracks the selection.
  */
 export declare function createTranslatableController(options: TranslatableOptions): TranslatableController;
+type LocalizedField<V> = V extends (...args: never[]) => unknown ? V : V extends Date ? V : V extends readonly (infer Item)[] ? LocalizedField<Item>[] : V extends Record<string, string> ? string : V extends object ? RecordForLocale<V> : V;
+/**
+ * What `getRecordForLocale` makes of `T`: a field typed `Record<string, string>`
+ * becomes `string`, an array maps its items, any other object maps its fields,
+ * and every other type stays. The root is never replaced.
+ *
+ * A nested `{ a: string; b: string }` field reads as a translation map here,
+ * though at run time only `locales` tells the two apart. A map without the
+ * selected locale is also left as it is at run time, so its type is the
+ * translated one only for a locale the data covers.
+ */
+export type RecordForLocale<T> = {
+    [K in keyof T]: LocalizedField<T[K]>;
+};
 /**
  * A copy of `record` where every object holding `locale` as an own key is
  * replaced by its value at that key, at any depth and inside arrays. Nodes
@@ -29,4 +43,5 @@ export declare function createTranslatableController(options: TranslatableOption
  * (`id` is Indonesian), so pass `locales` to also keep objects that have other
  * keys, such as a nested `{ id, name }` reference, from being read as a map.
  */
-export declare function getRecordForLocale<T extends object | null | undefined>(record: T, locale: string, locales?: readonly string[]): T extends object ? Record<string, unknown> : T;
+export declare function getRecordForLocale<T extends object | null | undefined>(record: T, locale: string, locales?: readonly string[]): T extends object ? RecordForLocale<T> : T;
+export {};

package/dist/i18n/translatable.js

@@ -1,56 +1,49 @@
+import { isPlainObject } from "../guards.js";
 import { createMicroStore } from "../store/micro-store.js";
+// src/i18n/translatable.ts
+/**
+* The state behind a multi-locale editor: which locale is on screen. The
+* form values themselves stay in the form; this only tracks the selection.
+*/
 function createTranslatableController(options) {
-  const { locales, defaultLocale } = options;
-  const first = locales[0];
-  if (first === void 0) {
-    throw new Error("A translatable controller needs at least one locale");
-  }
-  const store = createMicroStore({
-    locales,
-    selectedLocale: defaultLocale !== void 0 && locales.includes(defaultLocale) ? defaultLocale : first
-  });
-  return {
-    getSnapshot: store.getSnapshot,
-    subscribe: store.subscribe,
-    destroy: store.destroy,
-    selectLocale(locale) {
-      if (!locales.includes(locale)) {
-        throw new Error(
-          `Locale "${locale}" is not one of: ${locales.join(", ")}`
-        );
-      }
-      store.setState({ selectedLocale: locale });
-    }
-  };
-}
-function isPlainObject(value) {
-  if (typeof value !== "object" || value === null) return false;
-  const proto = Object.getPrototypeOf(value);
-  return proto === Object.prototype || proto === null;
+	const { locales, defaultLocale } = options;
+	const first = locales[0];
+	if (first === void 0) throw new Error("A translatable controller needs at least one locale");
+	const store = createMicroStore({
+		locales,
+		selectedLocale: defaultLocale !== void 0 && locales.includes(defaultLocale) ? defaultLocale : first
+	});
+	return {
+		getSnapshot: store.getSnapshot,
+		subscribe: store.subscribe,
+		destroy: store.destroy,
+		selectLocale(locale) {
+			if (!locales.includes(locale)) throw new Error(`Locale "${locale}" is not one of: ${locales.join(", ")}`);
+			store.setState({ selectedLocale: locale });
+		}
+	};
 }
 function pick(node, locale, locales, isRoot) {
-  if (Array.isArray(node)) {
-    return node.map((item) => pick(item, locale, locales, false));
-  }
-  if (!isPlainObject(node)) return node;
-  if (!isRoot && isTranslationMap(node, locale, locales)) {
-    return pick(node[locale], locale, locales, false);
-  }
-  return Object.fromEntries(
-    Object.entries(node).map(([key, value]) => [
-      key,
-      pick(value, locale, locales, false)
-    ])
-  );
+	if (Array.isArray(node)) return node.map((item) => pick(item, locale, locales, false));
+	if (!isPlainObject(node)) return node;
+	if (!isRoot && isTranslationMap(node, locale, locales)) return pick(node[locale], locale, locales, false);
+	return Object.fromEntries(Object.entries(node).map(([key, value]) => [key, pick(value, locale, locales, false)]));
 }
 function isTranslationMap(node, locale, locales) {
-  if (!Object.hasOwn(node, locale)) return false;
-  return !locales || Object.keys(node).every((key) => locales.includes(key));
+	if (!Object.hasOwn(node, locale)) return false;
+	return !locales || Object.keys(node).every((key) => locales.includes(key));
 }
+/**
+* A copy of `record` where every object holding `locale` as an own key is
+* replaced by its value at that key, at any depth and inside arrays. Nodes
+* without the key are kept as they are, so a record missing the locale still
+* shows the translatable object.
+*
+* The record itself is never replaced. A locale code can equal a field name
+* (`id` is Indonesian), so pass `locales` to also keep objects that have other
+* keys, such as a nested `{ id, name }` reference, from being read as a map.
+*/
 function getRecordForLocale(record, locale, locales) {
-  return pick(record, locale, locales, true);
+	return pick(record, locale, locales, true);
 }
-export {
-  createTranslatableController,
-  getRecordForLocale
-};
+export { createTranslatableController, getRecordForLocale };