npm - alepha - Versions diffs - 0.11.4 → 0.11.5 - Mend

alepha 0.11.4 → 0.11.5

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 (47) hide show

package/react/head.d.ts CHANGED Viewed

@@ -1 +1,120 @@
-export * from '@alepha/react-head';
+import * as _alepha_core1 from "alepha";
+import { Descriptor, KIND } from "alepha";
+import { PageConfigSchema, PageRoute, ReactRouterState, TPropsDefault, TPropsParentDefault } from "alepha/react";
+import { ServerTimingProvider } from "alepha/server";
+//#region src/interfaces/Head.d.ts
+interface Head extends SimpleHead {
+  description?: string;
+  keywords?: string[];
+  author?: string;
+  robots?: string;
+  themeColor?: string;
+  viewport?: string | {
+    width?: string;
+    height?: string;
+    initialScale?: string;
+    maximumScale?: string;
+    userScalable?: "no" | "yes" | "0" | "1";
+    interactiveWidget?: "resizes-visual" | "resizes-content" | "overlays-content";
+  };
+  og?: {
+    title?: string;
+    description?: string;
+    image?: string;
+    url?: string;
+    type?: string;
+  };
+  twitter?: {
+    card?: string;
+    title?: string;
+    description?: string;
+    image?: string;
+    site?: string;
+  };
+}
+interface SimpleHead {
+  title?: string;
+  titleSeparator?: string;
+  htmlAttributes?: Record<string, string>;
+  bodyAttributes?: Record<string, string>;
+  meta?: Array<{
+    name: string;
+    content: string;
+  }>;
+}
+//#endregion
+//#region src/providers/HeadProvider.d.ts
+declare class HeadProvider {
+  global?: Head | (() => Head);
+  protected getGlobalHead(): Head | undefined;
+  fillHead(state: ReactRouterState): void;
+  protected fillHeadByPage(page: PageRoute, state: ReactRouterState, props: Record<string, any>): void;
+}
+//#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;
+}
+//#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) => UseHeadReturn;
+type UseHeadOptions = Head | ((previous?: Head) => Head);
+type UseHeadReturn = [Head, (head?: Head | ((previous?: Head) => Head)) => void];
+//#endregion
+//#region src/providers/ServerHeadProvider.d.ts
+declare class ServerHeadProvider {
+  protected readonly headProvider: HeadProvider;
+  protected readonly serverTimingProvider: ServerTimingProvider;
+  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>;
+  protected escapeHtml(str: string): string;
+}
+//#endregion
+//#region src/index.d.ts
+declare module "alepha/react" {
+  interface PageDescriptorOptions<TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = TPropsDefault, TPropsParent extends object = TPropsParentDefault> {
+    head?: Head | ((props: TProps, previous?: Head) => Head);
+  }
+  interface ReactRouterState {
+    head: Head;
+  }
+}
+/**
+ * Fill `<head>` server & client side.
+ *
+ * @see {@link ServerHeadProvider}
+ * @module alepha.react.head
+ */
+declare const AlephaReactHead: _alepha_core1.Service<_alepha_core1.Module<{}>>;
+//#endregion
+export { $head, AlephaReactHead, Head, HeadDescriptor, HeadDescriptorOptions, ServerHeadProvider, SimpleHead, UseHeadOptions, UseHeadReturn, useHead };
+//# sourceMappingURL=index.d.ts.map

package/react/i18n.d.ts CHANGED Viewed

@@ -1 +1,168 @@
-export * from '@alepha/react-i18n';
+import * as _alepha_core1 from "alepha";
+import { Alepha, Descriptor, KIND, TypeBoxError } from "alepha";
+import { DateTime, DateTimeProvider } from "alepha/datetime";
+import * as _alepha_logger0 from "alepha/logger";
+import * as _alepha_server_cookies0 from "alepha/server/cookies";
+import * as typebox0 from "typebox";
+//#region src/components/Localize.d.ts
+interface LocalizeProps {
+  value: string | number | Date | DateTime | TypeBoxError;
+  /**
+   * Options for number formatting (when value is a number)
+   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/NumberFormat
+   */
+  number?: Intl.NumberFormatOptions;
+  /**
+   * Options for date formatting (when value is a Date or DateTime)
+   * Can be:
+   * - A dayjs format string (e.g., "LLL", "YYYY-MM-DD", "dddd, MMMM D YYYY")
+   * - "fromNow" for relative time (e.g., "2 hours ago")
+   * - Intl.DateTimeFormatOptions for native formatting
+   * @see https://day.js.org/docs/en/display/format
+   * @see https://day.js.org/docs/en/display/from-now
+   */
+  date?: string | "fromNow" | Intl.DateTimeFormatOptions;
+  /**
+   * Timezone to display dates in (when value is a Date or DateTime)
+   * Uses IANA timezone names (e.g., "America/New_York", "Europe/Paris", "Asia/Tokyo")
+   * @see https://day.js.org/docs/en/timezone/timezone
+   */
+  timezone?: string;
+}
+declare const Localize: (props: LocalizeProps) => string;
+//#endregion
+//#region src/hooks/useI18n.d.ts
+/**
+ * Hook to access the i18n service.
+ */
+declare const useI18n: <S extends object, K$1 extends keyof ServiceDictionary<S>>() => I18nProvider<S, K$1>;
+type ServiceDictionary<T extends object> = { [K in keyof T]: T[K] extends DictionaryDescriptor<infer U> ? U : never };
+//#endregion
+//#region src/providers/I18nProvider.d.ts
+declare class I18nProvider<S extends object, K$1 extends keyof ServiceDictionary<S>> {
+  protected logger: _alepha_logger0.Logger;
+  protected alepha: Alepha;
+  protected dateTimeProvider: DateTimeProvider;
+  protected cookie: _alepha_server_cookies0.AbstractCookieDescriptor<typebox0.TString>;
+  readonly registry: Array<{
+    name: string;
+    lang: string;
+    loader: () => Promise<Record<string, string>>;
+    translations: Record<string, string>;
+  }>;
+  options: {
+    fallbackLang: string;
+  };
+  dateFormat: {
+    format: (value: Date) => string;
+  };
+  numberFormat: {
+    format: (value: number) => string;
+  };
+  get languages(): string[];
+  constructor();
+  protected readonly onRender: _alepha_core1.HookDescriptor<"server:onRequest">;
+  protected readonly onStart: _alepha_core1.HookDescriptor<"start">;
+  protected refreshLocale(): void;
+  setLang: (lang: string) => Promise<void>;
+  protected readonly mutate: _alepha_core1.HookDescriptor<"state:mutate">;
+  get lang(): string;
+  translate: (key: string, args?: string[]) => string;
+  readonly l: (value: I18nLocalizeType, options?: I18nLocalizeOptions) => string;
+  readonly tr: (key: keyof ServiceDictionary<S>[K$1], options?: {
+    args?: string[];
+    default?: string;
+  }) => string;
+  protected render(item: string, args: string[]): string;
+}
+type I18nLocalizeType = string | number | Date | DateTime | TypeBoxError;
+interface I18nLocalizeOptions {
+  /**
+   * Options for number formatting (when value is a number)
+   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/NumberFormat
+   */
+  number?: Intl.NumberFormatOptions;
+  /**
+   * Options for date formatting (when value is a Date or DateTime)
+   * Can be:
+   * - A dayjs format string (e.g., "LLL", "YYYY-MM-DD", "dddd, MMMM D YYYY")
+   * - "fromNow" for relative time (e.g., "2 hours ago")
+   * - Intl.DateTimeFormatOptions for native formatting
+   * @see https://day.js.org/docs/en/display/format
+   * @see https://day.js.org/docs/en/display/from-now
+   */
+  date?: string | "fromNow" | Intl.DateTimeFormatOptions;
+  /**
+   * Timezone to display dates in (when value is a Date or DateTime)
+   * Uses IANA timezone names (e.g., "America/New_York", "Europe/Paris", "Asia/Tokyo")
+   * @see https://day.js.org/docs/en/timezone/timezone
+   */
+  timezone?: string;
+}
+//#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;
+};
+interface DictionaryDescriptorOptions<T extends Record<string, string>> {
+  lang?: string;
+  name?: string;
+  lazy: () => Promise<{
+    default: T;
+  }>;
+}
+declare class DictionaryDescriptor<T extends Record<string, string>> extends Descriptor<DictionaryDescriptorOptions<T>> {
+  protected provider: I18nProvider<object, never>;
+  protected onInit(): void;
+}
+//#endregion
+//#region src/index.d.ts
+declare module "alepha" {
+  interface State {
+    "react.i18n.lang"?: string;
+  }
+}
+/**
+ * Add i18n support to your Alepha React application. SSR and CSR compatible.
+ *
+ * It supports lazy loading of translations and provides a context to access the current language.
+ *
+ * @module alepha.react.i18n
+ */
+declare const AlephaReactI18n: _alepha_core1.Service<_alepha_core1.Module<{}>>;
+//#endregion
+export { $dictionary, AlephaReactI18n, DictionaryDescriptor, DictionaryDescriptorOptions, I18nLocalizeOptions, I18nLocalizeType, I18nProvider, Localize, type LocalizeProps, ServiceDictionary, useI18n };
+//# sourceMappingURL=index.d.ts.map