npm - alepha - Versions diffs - 0.9.2 → 0.9.3 - Mend

alepha 0.9.2 → 0.9.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (41) hide show

package/react/head.d.ts CHANGED Viewed

@@ -1,5 +1,6 @@
-import * as _alepha_core0$1 from "alepha";
+import * as _alepha_core1 from "alepha";
 import * as _alepha_core0 from "alepha";
+import { Descriptor, KIND } from "alepha";
 import { PageConfigSchema, PageReactContext, PageRoute, RouterState, TPropsDefault, TPropsParentDefault } from "alepha/react";
 //#region src/interfaces/Head.d.ts
@@ -44,21 +45,58 @@ interface SimpleHead {
 }
 //# sourceMappingURL=Head.d.ts.map
 //#endregion
-//#region src/hooks/useHead.d.ts
-declare const useHead: (head?: Head | ((previous?: Head) => Head)) => void;
-//# sourceMappingURL=useHead.d.ts.map
-//#endregion
 //#region src/providers/HeadProvider.d.ts
 declare class HeadProvider {
+  global?: Head | (() => Head);
+  protected getGlobalHead(): Head | undefined;
   fillHead(state: RouterState, context: PageReactContext): void;
   protected fillHeadByPage(page: PageRoute, context: PageReactContext, props: Record<string, any>): void;
 }
 //# sourceMappingURL=HeadProvider.d.ts.map
 //#endregion
+//#region src/descriptors/$head.d.ts
+/**
+ * Set global `<head>` options for the application.
+ */
+declare const $head: {
+  (options: HeadDescriptorOptions): HeadDescriptor;
+  [KIND]: typeof HeadDescriptor;
+};
+type HeadDescriptorOptions = Head | (() => Head);
+declare class HeadDescriptor extends Descriptor<HeadDescriptorOptions> {
+  protected readonly provider: HeadProvider;
+  protected onInit(): void;
+}
+//# sourceMappingURL=$head.d.ts.map
+//#endregion
+//#region src/hooks/useHead.d.ts
+/**
+ * ```tsx
+ * const App = () => {
+ *   const [head, setHead] = useHead({
+ *     // will set the document title on the first render
+ *     title: "My App",
+ *   });
+ *
+ *   return (
+ *     // This will update the document title when the button is clicked
+ *     <button onClick={() => setHead({ title: "Change Title" })}>
+ *       Change Title {head.title}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare const useHead: (options?: UseHeadOptions) => void;
+type UseHeadOptions = Head | ((previous?: Head) => Head);
+type UseHeadReturn = [Head, (head?: Head | ((previous?: Head) => Head)) => void];
+//# sourceMappingURL=useHead.d.ts.map
+//#endregion
 //#region src/providers/ServerHeadProvider.d.ts
 declare class ServerHeadProvider {
   protected readonly headProvider: HeadProvider;
-  protected readonly onServerRenderEnd: _alepha_core0$1.HookDescriptor<"react:server:render:end">;
+  protected readonly onServerRenderEnd: _alepha_core1.HookDescriptor<"react:server:render:end">;
   renderHead(template: string, head: SimpleHead): string;
   protected mergeAttributes(existing: string, attrs: Record<string, string>): string;
   protected parseAttributes(attrStr: string): Record<string, string>;
@@ -81,9 +119,9 @@ declare module "alepha/react" {
  * @see {@link ServerHeadProvider}
  * @module alepha.react.head
  */
-declare const AlephaReactHead: _alepha_core0.ModuleDescriptor;
+declare const AlephaReactHead: _alepha_core0.Service<_alepha_core0.Module>;
 //# sourceMappingURL=index.d.ts.map
 //#endregion
-export { AlephaReactHead, Head, ServerHeadProvider, SimpleHead, useHead };
+export { $head, AlephaReactHead, Head, HeadDescriptor, HeadDescriptorOptions, ServerHeadProvider, SimpleHead, UseHeadOptions, UseHeadReturn, useHead };
 //# sourceMappingURL=index.d.ts.map

package/react/i18n.d.ts CHANGED Viewed

@@ -1,11 +1,14 @@
-import * as _alepha_core0$1 from "alepha";
+import * as _alepha_core1 from "alepha";
 import * as _alepha_core0 from "alepha";
 import { Alepha, Descriptor, KIND } from "alepha";
+import * as _alepha_server_cookies0 from "alepha/server/cookies";
+import * as _sinclair_typebox0 from "@sinclair/typebox";
 //#region src/providers/I18nProvider.d.ts
 declare class I18nProvider {
-  logger: _alepha_core0$1.Logger;
+  logger: _alepha_core1.Logger;
   alepha: Alepha;
+  cookie: _alepha_server_cookies0.AbstractCookieDescriptor<_sinclair_typebox0.TString>;
   registry: Array<{
     name: string;
     lang: string;
@@ -15,15 +18,49 @@ declare class I18nProvider {
   options: {
     fallbackLang: string;
   };
-  onRender: _alepha_core0$1.HookDescriptor<"server:onRequest">;
-  onStart: _alepha_core0$1.HookDescriptor<"start">;
+  get languages(): string[];
+  onRender: _alepha_core1.HookDescriptor<"server:onRequest">;
+  onStart: _alepha_core1.HookDescriptor<"start">;
   setLang(lang: string): Promise<void>;
   get lang(): string;
-  translate: (key: string) => string;
+  translate: (key: string, args?: string[]) => string;
+  protected render(item: string, args: string[]): string;
 }
 //# sourceMappingURL=I18nProvider.d.ts.map
 //#endregion
 //#region src/descriptors/$dictionary.d.ts
+/**
+ * Register a dictionary entry for translations.
+ *
+ * It allows you to define a set of translations for a specific language.
+ * Entry can be lazy-loaded, which is useful for large dictionaries or when translations are not needed immediately.
+ *
+ * @example
+ * ```ts
+ * import { $dictionary } from "alepha/react/i18n";
+ *
+ * const Example = () => {
+ *   const { tr } = useI18n<App, "en">();
+ *   return <div>{tr("hello")}</div>; //
+ * }
+ *
+ * class App {
+ *
+ *   en = $dictionary({
+ *     // { default: { hello: "Hey" } }
+ *     lazy: () => import("./translations/en.ts"),
+ *   });
+ *
+ *   home = $page({
+ *     path: "/",
+ *     component: Example,
+ *   })
+ * }
+ *
+ * run(App);
+ * ```
+ */
 declare const $dictionary: {
   <T extends Record<string, string>>(options: DictionaryDescriptorOptions<T>): DictionaryDescriptor<T>;
   [KIND]: typeof DictionaryDescriptor;
@@ -48,9 +85,11 @@ declare class DictionaryDescriptor<T extends Record<string, string>> extends Des
 declare const useI18n: <S extends object, K extends keyof ServiceDictionary<S>>() => {
   lang: string;
   setLang: (lang: string) => Promise<void>;
-  tr: (key: keyof ServiceDictionary<S>[K]) => string;
+  tr: (key: keyof ServiceDictionary<S>[K] | string, args?: string[]) => string;
+  languages: string[];
 };
 type ServiceDictionary<T extends object> = { [K in keyof T]: T[K] extends DictionaryDescriptor<infer U> ? U : never };
+//# sourceMappingURL=useI18n.d.ts.map
 //#endregion
 //#region src/index.d.ts
 declare module "alepha" {
@@ -65,9 +104,9 @@ declare module "alepha" {
  *
  * @module alepha.react.i18n
  */
-declare const AlephaReactI18n: _alepha_core0.ModuleDescriptor;
+declare const AlephaReactI18n: _alepha_core0.Service<_alepha_core0.Module>;
 //# sourceMappingURL=index.d.ts.map
 //#endregion
-export { $dictionary, AlephaReactI18n, DictionaryDescriptor, DictionaryDescriptorOptions, I18nProvider, useI18n };
+export { $dictionary, AlephaReactI18n, DictionaryDescriptor, DictionaryDescriptorOptions, I18nProvider, ServiceDictionary, useI18n };
 //# sourceMappingURL=index.d.ts.map