@intentic/extension-ui 1.304.0 → 1.306.0

package/README.md

@@ -29,9 +29,11 @@ authors is a marketplace-phase task.
 
 - [src/index.ts](src/index.ts), the whole surface: which components and helpers an extension may render with.
 - [src/format.ts](src/format.ts): the shared formatters, so two extensions render a duration the same way.
-- [src/i18n.ts](src/i18n.ts): the extension's words. `extensionT(id)` is its translator, bound to its own slice of
-  the host's one message tree; `registerExtensionMessages` mounts a catalog, which is what the host does before
-  `activate` and what a test calling `activate` itself has to do instead.
+- [src/i18n.ts](src/i18n.ts): the extension's words. `extensionI18n(id, base, load)` is the one call every in-repo
+  extension's `src/i18n.ts` now makes, returning the catalog the host mounts and the translator its components read;
+  `extensionT(id)` is that translator alone, bound to its own slice of the host's one message tree, and
+  `registerExtensionMessages` mounts a catalog, which is what the host does before `activate` and what a test
+  calling `activate` itself has to do instead.
 
 ## The one control worth calling out
 

package/dist/types/extension-ui/src/i18n.d.ts

@@ -2,6 +2,17 @@ import { type Locale, type MessageTree } from "../../ui/src/i18n/index.js";
 import type { Ref } from "vue";
 export type ExtensionT = (key: string, values?: Record<string, unknown>, plural?: number) => string;
 export declare const extensionT: (extensionId: string) => ExtensionT;
+export declare const extensionI18n: (extensionId: string, base: MessageTree, load: (locale: string) => Promise<{
+    readonly default: MessageTree;
+}>) => {
+    readonly messages: {
+        readonly base: MessageTree;
+        readonly load: (locale: string) => Promise<{
+            readonly default: MessageTree;
+        }>;
+    };
+    readonly t: ExtensionT;
+};
 export declare const registerExtensionMessages: (extensionId: string, messages: {
     readonly base: MessageTree;
     readonly load: (locale: string) => Promise<{

package/dist/types/ui/src/components/overlays/ContextMenu.vue.d.ts

@@ -7,6 +7,10 @@ type __VLS_Props = {
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
     show: (event: Event) => void;
     hide: () => void;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    hide: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onHide?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/types/ui/src/composables/useNow.d.ts

@@ -1,2 +1,2 @@
-import { type MaybeRefOrGetter, type Ref } from "vue";
-export declare function useNow(active?: MaybeRefOrGetter<boolean>): Ref<number>;
+import { type ComputedRef, type MaybeRefOrGetter } from "vue";
+export declare function useNow(active?: MaybeRefOrGetter<boolean>): ComputedRef<number>;

package/dist/types/ui/src/icons/iconSets.d.ts

@@ -557,4 +557,4 @@ export declare const ICONS: {
 };
 export type IconName = keyof typeof ICONS;
 export declare const isIconName: (name: string) => name is IconName;
-export declare const areaIcon: (area: string, fallback?: IconName) => IconName | undefined;
+export declare const sectionIcon: (section: string, fallback?: IconName) => IconName | undefined;

package/dist/types/ui/src/lib/format.d.ts

@@ -2,7 +2,9 @@ export declare const formatBytes: (bytes: number | undefined) => string;
 export declare const formatDuration: (seconds: number) => string;
 export declare const formatTokens: (tokens: number) => string;
 export declare const initialsOf: (name: string) => string | undefined;
+export declare const formatFixed: (value: number, digits: number) => string;
 export declare const setFormatLocale: (tag: string) => void;
+export declare const formatPercent: (percent: number) => string;
 export declare const formatDate: (at: number) => string;
 export declare const formatDateLong: (at: number | string) => string;
 export declare const formatDayMonth: (at: number) => string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentic/extension-ui",
-  "version": "1.304.0",
+  "version": "1.306.0",
   "description": "The UI kit intentic extensions render with, host-provided at runtime (the app's own components via the import map), so extension UI is always native to the shell",
   "license": "MIT",
   "type": "module",

package/src/i18n.ts

@@ -36,6 +36,27 @@ export type ExtensionT = (key: string, values?: Record<string, unknown>, plural?
  */
 export const extensionT = (extensionId: string): ExtensionT => useT(`ext.${extensionId}`);
 
+/**
+ * One extension's words in one call: the catalog the host mounts (`messages`) and the translator its components
+ * read (`t`), which were the same twenty lines in every in-repo extension. The loader stays at the CALL SITE
+ * because its specifier has to be a literal template — that is what emits one chunk per language rather than one
+ * request carrying all of them — and the id is passed in rather than derived, so this package's published types
+ * still reach no further than `vue` and the locale table.
+ *
+ * ```ts
+ * // src/i18n.ts
+ * export const { messages, t } = extensionI18n(extensionIdOf(manifest), base, (locale) => import(`./locales/${locale}.json`));
+ * ```
+ */
+export const extensionI18n = (
+    extensionId: string,
+    base: MessageTree,
+    load: (locale: string) => Promise<{ readonly default: MessageTree }>,
+): {
+    readonly messages: { readonly base: MessageTree; readonly load: (locale: string) => Promise<{ readonly default: MessageTree }> };
+    readonly t: ExtensionT;
+} => ({ messages: { base, load }, t: extensionT(extensionId) });
+
 /**
  * Mounts an extension's own messages under its slice of the tree — what the HOST does before it calls `activate`, and
  * what a test that calls `activate` itself has to do instead, or every label it asserts on reads as a dotted key.