@primate/core 0.8.2 → 0.8.4

package/lib/private/frontend.js

@@ -210,9 +210,14 @@ export default function frontend_module(init) {
                                     for (const view of views) {
                                         const { path } = view.debase(views_base, "/");
                                         contents += `export { default as ${await normalize(path)} }
-                from "view:${path}";\n`;
+                      from "view:${path}";\n`;
                                     }
-                                    return { contents, resolveDir: app.root.path };
+                                    return {
+                                        contents,
+                                        resolveDir: app.root.path,
+                                        watchDirs: [views_base.path],
+                                        watchFiles: views.map(view => view.path),
+                                    };
                                 });
                                 const filter = new RegExp(`(${extensions.map(e => e.replace(".", "\\.")).join("|")})$`);
                                 build.onLoad({ filter }, async (args) => {

package/lib/private/i18n/API.d.ts

@@ -1,17 +1,30 @@
+import type Catalog from "#i18n/Catalog";
 import type Catalogs from "#i18n/Catalogs";
+import type { DotPaths, EntriesOf, ParamsFromEntries, PathValue } from "#i18n/types";
 type RestoreRequest = {
     cookies?: Record<string, string | undefined>;
 };
+export type Schema<C extends Catalogs> = C[keyof C] extends Catalog ? C[keyof C] : never;
+export type Key<C extends Catalogs> = DotPaths<Schema<C>> & string;
+type Resolved<C extends Catalogs, K extends string> = [
+    K
+] extends [Key<C>] ? PathValue<Schema<C>, K> : never;
+type Message<C extends Catalogs, K extends Key<C>> = Extract<Resolved<C, K>, string>;
+type Params<C extends Catalogs, K extends Key<C>> = ParamsFromEntries<EntriesOf<Message<C, K>>>;
+export type Args<C extends Catalogs, K extends string> = K extends Key<C> ? ([EntriesOf<Message<C, K>>] extends [never] ? [key: K] : [key: K, params: Params<C, K>]) : [`[i18n] Missing locale key "${K & string}".`];
+export type Result<C extends Catalogs, K extends string> = K extends Key<C> ? (Resolved<C, K> extends string ? string : Resolved<C, K>) : string;
+export type TFn<C extends Catalogs> = <K extends string>(...args: Args<C, K>) => Result<C, K>;
 export default interface API<C extends Catalogs> {
-    readonly defaultLocale: keyof C & string;
-    readonly locales: readonly (keyof C & string)[];
-    readonly catalogs: C;
-    readonly currency: string;
-    readonly locale: {
+    defaultLocale: keyof C & string;
+    locales: readonly (keyof C & string)[];
+    catalogs: C;
+    currency: string;
+    locale: {
         get(): keyof C & string;
         set(locale: keyof C & string): void;
     };
     restore(request?: RestoreRequest): void;
+    with(locale: keyof C & string): TFn<C>;
 }
 export {};
 //# sourceMappingURL=API.d.ts.map