alepha 0.7.5 → 0.7.7

package/react/auth.d.ts

@@ -1,307 +1,185 @@
-import * as _alepha_core from '@alepha/core';
-import { Async, KIND, OPTIONS, Alepha, Module } from '@alepha/core';
-import { UserAccountToken } from '@alepha/security';
-import * as _alepha_server from '@alepha/server';
-import { HttpVirtualClient, HttpClient } from '@alepha/server';
-import * as _alepha_server_cookies from '@alepha/server-cookies';
-import { ServerCookiesProvider, Cookies } from '@alepha/server-cookies';
-import { Configuration } from 'openid-client';
-
-/** Symbol key applied to readonly types */
-declare const ReadonlyKind: unique symbol;
-/** Symbol key applied to optional types */
-declare const OptionalKind: unique symbol;
-/** Symbol key applied to types */
-declare const Hint: unique symbol;
-/** Symbol key applied to types */
-declare const Kind: unique symbol;
-
-type TReadonly<T extends TSchema> = T & {
-    [ReadonlyKind]: 'Readonly';
-};
-
-type StringFormatOption = 'date-time' | 'time' | 'date' | 'email' | 'idn-email' | 'hostname' | 'idn-hostname' | 'ipv4' | 'ipv6' | 'uri' | 'uri-reference' | 'iri' | 'uuid' | 'iri-reference' | 'uri-template' | 'json-pointer' | 'relative-json-pointer' | 'regex' | ({} & string);
-type StringContentEncodingOption = '7bit' | '8bit' | 'binary' | 'quoted-printable' | 'base64' | ({} & string);
-interface StringOptions extends SchemaOptions {
-    /** The maximum string length */
-    maxLength?: number;
-    /** The minimum string length */
-    minLength?: number;
-    /** A regular expression pattern this string should match */
-    pattern?: string;
-    /** A format this string should match */
-    format?: StringFormatOption;
-    /** The content encoding for this string */
-    contentEncoding?: StringContentEncodingOption;
-    /** The content media type for this string */
-    contentMediaType?: string;
-}
-interface TString extends TSchema, StringOptions {
-    [Kind]: 'String';
-    static: string;
-    type: 'string';
-}
-
-interface NumberOptions extends SchemaOptions {
-    exclusiveMaximum?: number;
-    exclusiveMinimum?: number;
-    maximum?: number;
-    minimum?: number;
-    multipleOf?: number;
-}
-interface TNumber extends TSchema, NumberOptions {
-    [Kind]: 'Number';
-    static: number;
-    type: 'number';
-}
-
-type TOptional<T extends TSchema> = T & {
-    [OptionalKind]: 'Optional';
-};
-
-/** Creates a static type from a TypeBox type */
-type Static<Type extends TSchema, Params extends unknown[] = [], Result = (Type & {
-    params: Params;
-})['static']> = Result;
-
-type ReadonlyOptionalPropertyKeys<T extends TProperties> = {
-    [K in keyof T]: T[K] extends TReadonly<TSchema> ? (T[K] extends TOptional<T[K]> ? K : never) : never;
-}[keyof T];
-type ReadonlyPropertyKeys<T extends TProperties> = {
-    [K in keyof T]: T[K] extends TReadonly<TSchema> ? (T[K] extends TOptional<T[K]> ? never : K) : never;
-}[keyof T];
-type OptionalPropertyKeys<T extends TProperties> = {
-    [K in keyof T]: T[K] extends TOptional<TSchema> ? (T[K] extends TReadonly<T[K]> ? never : K) : never;
-}[keyof T];
-type RequiredPropertyKeys<T extends TProperties> = keyof Omit<T, ReadonlyOptionalPropertyKeys<T> | ReadonlyPropertyKeys<T> | OptionalPropertyKeys<T>>;
-type ObjectStaticProperties<T extends TProperties, R extends Record<keyof any, unknown>> = Evaluate<(Readonly<Partial<Pick<R, ReadonlyOptionalPropertyKeys<T>>>> & Readonly<Pick<R, ReadonlyPropertyKeys<T>>> & Partial<Pick<R, OptionalPropertyKeys<T>>> & Required<Pick<R, RequiredPropertyKeys<T>>>)>;
-type ObjectStatic<T extends TProperties, P extends unknown[]> = ObjectStaticProperties<T, {
-    [K in keyof T]: Static<T[K], P>;
-}>;
-type TPropertyKey = string | number;
-type TProperties = Record<TPropertyKey, TSchema>;
-type TAdditionalProperties = undefined | TSchema | boolean;
-interface ObjectOptions extends SchemaOptions {
-    /** Additional property constraints for this object */
-    additionalProperties?: TAdditionalProperties;
-    /** The minimum number of properties allowed on this object */
-    minProperties?: number;
-    /** The maximum number of properties allowed on this object */
-    maxProperties?: number;
-}
-interface TObject<T extends TProperties = TProperties> extends TSchema, ObjectOptions {
-    [Kind]: 'Object';
-    static: ObjectStatic<T, this['params']>;
-    additionalProperties?: TAdditionalProperties;
-    type: 'object';
-    properties: T;
-    required?: string[];
-}
-
-type Evaluate<T> = T extends infer O ? {
-    [K in keyof O]: O[K];
-} : never;
-
-interface SchemaOptions {
-    $schema?: string;
-    /** Id for this schema */
-    $id?: string;
-    /** Title of this schema */
-    title?: string;
-    /** Description of this schema */
-    description?: string;
-    /** Default value for this schema */
-    default?: any;
-    /** Example values matching this schema */
-    examples?: any;
-    /** Optional annotation for readOnly */
-    readOnly?: boolean;
-    /** Optional annotation for writeOnly */
-    writeOnly?: boolean;
-    [prop: string]: any;
-}
-interface TKind {
-    [Kind]: string;
-}
-interface TSchema extends TKind, SchemaOptions {
-    [ReadonlyKind]?: string;
-    [OptionalKind]?: string;
-    [Hint]?: string;
-    params: unknown[];
-    static: unknown;
-}
+import * as _alepha_core1 from "@alepha/core";
+import * as _alepha_core52 from "@alepha/core";
+import { Alepha, Async, KIND, Module, OPTIONS } from "@alepha/core";
+import * as _alepha_server_cookies7 from "@alepha/server-cookies";
+import { Cookies, ServerCookiesProvider } from "@alepha/server-cookies";
+import * as _alepha_server41 from "@alepha/server";
+import { HttpClient } from "@alepha/server";
+import { Configuration } from "openid-client";
+import { HttpVirtualClient } from "@alepha/server-links";
+import { UserAccountToken } from "@alepha/security";
+import * as _sinclair_typebox2 from "@sinclair/typebox";
 
+//#region src/descriptors/$auth.d.ts
 declare const KEY = "AUTH";
 type AccessToken = string;
 interface AuthDescriptorOptions {
-    name?: string;
-    fallback?: () => Async<AccessToken>;
-    oidc?: {
-        issuer: string;
-        clientId: string;
-        clientSecret?: string;
-        redirectUri?: string;
-        useIdToken?: boolean;
-        logoutUri?: string;
-    };
+  name?: string;
+  fallback?: () => Async<AccessToken>;
+  oidc?: {
+    issuer: string;
+    clientId: string;
+    clientSecret?: string;
+    redirectUri?: string;
+    useIdToken?: boolean;
+    logoutUri?: string;
+  };
 }
 interface AuthDescriptor {
-    [KIND]: typeof KEY;
-    [OPTIONS]: AuthDescriptorOptions;
-    jwks: () => string;
+  [KIND]: typeof KEY;
+  [OPTIONS]: AuthDescriptorOptions;
+  jwks: () => string;
 }
 declare const $auth: {
-    (options: AuthDescriptorOptions): AuthDescriptor;
-    [KIND]: string;
+  (options: AuthDescriptorOptions): AuthDescriptor;
+  [KIND]: string;
 };
-
+//#endregion
+//#region src/providers/ReactAuthProvider.d.ts
 declare class ReactAuthProvider {
-    protected readonly log: _alepha_core.Logger;
-    protected readonly alepha: Alepha;
-    protected readonly serverCookiesProvider: ServerCookiesProvider;
-    protected authProviders: AuthProvider[];
-    protected readonly authorizationCode: _alepha_server_cookies.CookieDescriptor<TObject<{
-        codeVerifier: TOptional<TString>;
-        redirectUri: TOptional<TString>;
-    }>>;
-    protected readonly tokens: _alepha_server_cookies.CookieDescriptor<TObject<{
-        provider: TOptional<TString>;
-        access_token: TOptional<TString>;
-        expires_in: TOptional<TNumber>;
-        refresh_token: TOptional<TString>;
-        id_token: TOptional<TString>;
-        scope: TOptional<TString>;
-        issued_at: TOptional<TNumber>;
-    }>>;
-    readonly user: _alepha_server_cookies.CookieDescriptor<TObject<{
-        id: TString;
-        name: TOptional<TString>;
-        email: TOptional<TString>;
-        picture: TOptional<TString>;
-    }>>;
-    readonly onRender: _alepha_core.HookDescriptor<"react:server:render">;
-    protected readonly configure: _alepha_core.HookDescriptor<"configure">;
-    protected getAccessTokenFromCookies(tokens: SessionTokens): Promise<string | undefined>;
-    /**
-     * Configure Fastify to forward Session Access Token to Header Authorization.
-     */
-    protected readonly onRequest: _alepha_core.HookDescriptor<"server:onRequest">;
-    /**
-     *
-     * @param cookies
-     * @protected
-     */
-    protected refresh(cookies: Cookies): Promise<SessionTokens | undefined>;
-    /**
-     *
-     */
-    readonly login: _alepha_server.RouteDescriptor<{
-        query: TObject<{
-            redirect: TOptional<TString>;
-            provider: TOptional<TString>;
-        }>;
-    }>;
-    /**
-     *
-     */
-    readonly callback: _alepha_server.RouteDescriptor<{
-        query: TObject<{
-            provider: TOptional<TString>;
-        }>;
+  protected readonly log: _alepha_core1.Logger;
+  protected readonly alepha: Alepha;
+  protected readonly serverCookiesProvider: ServerCookiesProvider;
+  protected authProviders: AuthProvider[];
+  protected readonly authorizationCode: _alepha_server_cookies7.CookieDescriptor<_sinclair_typebox2.TObject<{
+    codeVerifier: _sinclair_typebox2.TOptional<_sinclair_typebox2.TString>;
+    redirectUri: _sinclair_typebox2.TOptional<_sinclair_typebox2.TString>;
+  }>>;
+  protected readonly tokens: _alepha_server_cookies7.CookieDescriptor<_sinclair_typebox2.TObject<{
+    provider: _sinclair_typebox2.TOptional<_sinclair_typebox2.TString>;
+    access_token: _sinclair_typebox2.TOptional<_sinclair_typebox2.TString>;
+    expires_in: _sinclair_typebox2.TOptional<_sinclair_typebox2.TNumber>;
+    refresh_token: _sinclair_typebox2.TOptional<_sinclair_typebox2.TString>;
+    id_token: _sinclair_typebox2.TOptional<_sinclair_typebox2.TString>;
+    scope: _sinclair_typebox2.TOptional<_sinclair_typebox2.TString>;
+    issued_at: _sinclair_typebox2.TOptional<_sinclair_typebox2.TNumber>;
+  }>>;
+  readonly user: _alepha_server_cookies7.CookieDescriptor<_sinclair_typebox2.TObject<{
+    id: _sinclair_typebox2.TString;
+    name: _sinclair_typebox2.TOptional<_sinclair_typebox2.TString>;
+    email: _sinclair_typebox2.TOptional<_sinclair_typebox2.TString>;
+    picture: _sinclair_typebox2.TOptional<_sinclair_typebox2.TString>;
+  }>>;
+  readonly onRender: _alepha_core1.HookDescriptor<"react:server:render:begin">;
+  protected readonly configure: _alepha_core1.HookDescriptor<"configure">;
+  protected getAccessTokenFromCookies(tokens: SessionTokens): Promise<string | undefined>;
+  /**
+   * Configure Fastify to forward Session Access Token to Header Authorization.
+   */
+  protected readonly onRequest: _alepha_core1.HookDescriptor<"server:onRequest">;
+  /**
+   *
+   * @param cookies
+   * @protected
+   */
+  protected refresh(cookies: Cookies): Promise<SessionTokens | undefined>;
+  readonly login: _alepha_server41.RouteDescriptor<{
+    query: _sinclair_typebox2.TObject<{
+      redirect: _sinclair_typebox2.TOptional<_sinclair_typebox2.TString>;
+      provider: _sinclair_typebox2.TOptional<_sinclair_typebox2.TString>;
     }>;
-    /**
-     *
-     * @param accessToken
-     * @protected
-     */
-    protected userFromAccessToken(accessToken: string): {
-        id: any;
-        name: any;
-        email: any;
-        picture: any;
-    } | undefined;
-    readonly logout: _alepha_server.RouteDescriptor<{
-        query: TObject<{
-            redirect: TOptional<TString>;
-            provider: TOptional<TString>;
-        }>;
+  }>;
+  readonly callback: _alepha_server41.RouteDescriptor<{
+    query: _sinclair_typebox2.TObject<{
+      provider: _sinclair_typebox2.TOptional<_sinclair_typebox2.TString>;
     }>;
-    /**
-     *
-     * @param name
-     * @protected
-     */
-    protected provider(name?: string): Promise<{
-        client: Configuration;
-        name: string;
-        redirectUri: string;
-        fallback?: () => Async<AccessToken>;
-        useIdToken?: boolean;
-        logoutUri?: string;
+  }>;
+  /**
+   *
+   * @param accessToken
+   * @protected
+   */
+  protected userFromAccessToken(accessToken: string): {
+    id: any;
+    name: any;
+    email: any;
+    picture: any;
+  } | undefined;
+  readonly logout: _alepha_server41.RouteDescriptor<{
+    query: _sinclair_typebox2.TObject<{
+      redirect: _sinclair_typebox2.TOptional<_sinclair_typebox2.TString>;
+      provider: _sinclair_typebox2.TOptional<_sinclair_typebox2.TString>;
     }>;
-    /**
-     *
-     * @param file
-     * @protected
-     */
-    protected isViteFile(file: string): boolean;
-}
-interface SessionTokens {
-    access_token?: string;
-    expires_in?: number;
-    refresh_token?: string;
-    id_token?: string;
-    scope?: string;
-    issued_at?: number;
-    provider?: string;
-}
-interface AuthProvider {
+  }>;
+  /**
+   *
+   * @param name
+   * @protected
+   */
+  protected provider(name?: string): Promise<{
+    client: Configuration;
     name: string;
     redirectUri: string;
-    client: {
-        get: () => Promise<Configuration>;
-    };
     fallback?: () => Async<AccessToken>;
     useIdToken?: boolean;
     logoutUri?: string;
+  }>;
+  /**
+   *
+   * @param file
+   * @protected
+   */
+  protected isViteFile(file: string): boolean;
+}
+interface SessionTokens {
+  access_token?: string;
+  expires_in?: number;
+  refresh_token?: string;
+  id_token?: string;
+  scope?: string;
+  issued_at?: number;
+  provider?: string;
+}
+interface AuthProvider {
+  name: string;
+  redirectUri: string;
+  client: {
+    get: () => Promise<Configuration>;
+  };
+  fallback?: () => Async<AccessToken>;
+  useIdToken?: boolean;
+  logoutUri?: string;
 }
 interface ReactUser {
-    id: string;
-    name?: string;
-    email?: string;
+  id: string;
+  name?: string;
+  email?: string;
 }
-
+//#endregion
+//#region src/hooks/useAuth.d.ts
 declare const useAuth: () => AuthHook;
 interface AuthHook {
-    user?: UserAccountToken;
-    logout: () => void;
-    login: (provider?: string) => void;
-    can: <T extends object>(name: keyof HttpVirtualClient<T>) => boolean;
+  user?: UserAccountToken;
+  logout: () => void;
+  login: (provider?: string) => void;
+  can: <T extends object>(name: keyof HttpVirtualClient<T>) => boolean;
 }
-
+//#endregion
+//#region src/services/ReactAuth.d.ts
 declare class ReactAuth {
-    protected readonly log: _alepha_core.Logger;
-    protected readonly alepha: Alepha;
-    protected readonly client: HttpClient;
-    static path: {
-        login: string;
-        callback: string;
-        logout: string;
-    };
-    readonly onRender: _alepha_core.HookDescriptor<"react:transition:begin">;
-    get user(): UserAccountToken | undefined;
-    protected getUserFromCookies(): UserAccountToken | undefined;
-    login(): void;
-    logout(): void;
-}
-
+  protected readonly log: _alepha_core52.Logger;
+  protected readonly alepha: Alepha;
+  protected readonly client: HttpClient;
+  static path: {
+    login: string;
+    callback: string;
+    logout: string;
+  };
+  readonly onRender: _alepha_core52.HookDescriptor<"react:transition:begin">;
+  get user(): UserAccountToken | undefined;
+  protected getUserFromCookies(): UserAccountToken | undefined;
+  login(): void;
+  logout(): void;
+}
+//#endregion
+//#region src/index.d.ts
 declare module "alepha/react" {
-    interface PageReactContext {
-        user?: UserAccountToken;
-    }
-    interface ReactHydrationState {
-        user?: ReactUser;
-    }
+  interface PageReactContext {
+    user?: UserAccountToken;
+  }
+  interface ReactHydrationState {
+    user?: ReactUser;
+  }
 }
 /**
  * Alepha React Authentication Module
@@ -312,8 +190,9 @@ declare module "alepha/react" {
  * @module alepha.react.auth
  */
 declare class AlephaReactAuth implements Module {
-    readonly name = "alepha.react.auth";
-    readonly $services: (alepha: Alepha) => void;
+  readonly name = "alepha.react.auth";
+  readonly $services: (alepha: Alepha) => void;
 }
-
-export { $auth, type AccessToken, AlephaReactAuth, type AuthDescriptor, type AuthDescriptorOptions, type AuthHook, type AuthProvider, ReactAuth, ReactAuthProvider, type ReactUser, type SessionTokens, useAuth };
+//#endregion
+export { $auth, AccessToken, AlephaReactAuth, AuthDescriptor, AuthDescriptorOptions, AuthHook, AuthProvider, ReactAuth, ReactAuthProvider, ReactUser, SessionTokens, useAuth };
+//# sourceMappingURL=index.d.ts.map

package/react/auth.js

@@ -1 +1 @@
-export * from '@alepha/react-auth';
+export * from '@alepha/react-auth'

package/react/head.cjs

@@ -0,0 +1,8 @@
+'use strict';
+var m = require('@alepha/react-head');
+Object.keys(m).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return m[k]; }
+	});
+});

package/react/head.d.ts

@@ -0,0 +1,86 @@
+import { PageConfigSchema, PageReactContext, PageRoute, RouterState, TPropsDefault, TPropsParentDefault } from "@alepha/react";
+import * as _alepha_core1 from "@alepha/core";
+import { Alepha, Module } from "@alepha/core";
+
+//#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/hooks/useHead.d.ts
+declare const useHead: (head?: Head | ((previous?: Head) => Head)) => void;
+//#endregion
+//#region src/providers/HeadProvider.d.ts
+declare class HeadProvider {
+  fillHead(state: RouterState, context: PageReactContext): void;
+  protected fillHeadByPage(page: PageRoute, context: PageReactContext, props: Record<string, any>): void;
+}
+//#endregion
+//#region src/providers/ServerHeadProvider.d.ts
+declare class ServerHeadProvider {
+  protected readonly headProvider: HeadProvider;
+  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 PageReactContext {
+    head: Head;
+  }
+}
+/**
+ * Alepha React Head Module
+ *
+ * @see {@link ServerHeadProvider}
+ * @module alepha.react.head
+ */
+declare class AlephaReactHead implements Module {
+  readonly name = "alepha.react.head";
+  readonly $services: (alepha: Alepha) => Alepha;
+}
+//#endregion
+export { AlephaReactHead, Head, ServerHeadProvider, SimpleHead, useHead };
+//# sourceMappingURL=index.d.ts.map

package/react/head.js

@@ -0,0 +1 @@
+export * from '@alepha/react-head'

package/react.cjs

@@ -1,12 +1,8 @@
 'use strict';
-
-var react = require('@alepha/react');
-
-
-
-Object.keys(react).forEach(function (k) {
+var m = require('@alepha/react');
+Object.keys(m).forEach(function (k) {
 	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
 		enumerable: true,
-		get: function () { return react[k]; }
+		get: function () { return m[k]; }
 	});
-});
+});