5htp-core 0.1.2 → 0.2.0

package/src/client/services/router/request/index.ts

@@ -0,0 +1,52 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Npm
+import { Location } from 'history'; 
+import type Bowser from 'bowser';
+
+// Core 
+import BaseRequest from '@common/router/request';
+
+// Specific
+import type ClientRouter from '..';
+import ApiClient from './api';
+import type ClientResponse from '../response';
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+
+/*----------------------------------
+- ROUTER
+----------------------------------*/
+// Since we do SSR, the server router can also be passed here
+export default class ClientRequest<TRouter extends ClientRouter = ClientRouter> extends BaseRequest {
+
+    public api: ApiClient;
+    public response?: ClientResponse<TRouter>;
+    public hash?: string;
+
+    public constructor( 
+        location: Location, 
+        public router: TRouter,
+        public app = router.app
+    ) {
+
+        super(location.pathname);
+
+        this.host = window.location.host;
+        this.hash = location.hash;
+
+        this.api = new ApiClient(this.app, this);
+    }
+
+    // To move to a service
+    public device(): Bowser.Parser.ParsedResult | undefined {
+        // We load bowser only when required
+        const Bowser = require("bowser");
+        return Bowser.parse(window.navigator.userAgent);
+    }
+}

package/src/client/services/router/response/index.tsx

@@ -0,0 +1,107 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Libs 
+import type ServerRouter from '@server/services/router';
+import type ServerResponse from '@server/services/router/response';
+
+import type { TRoute, TErrorRoute } from '@common/router';
+import BaseResponse from '@common/router/response';
+
+import type ClientApplication from '@client/app';
+import type { default as ClientRouter } from '@client/services/router'
+import type ClientResponse from '@client/services/router/response'
+import ClientRequest from '@client/services/router/request'
+import ClientPage from '@client/services/router/response/page'
+import { history } from '@client/services/router/request/history';
+import CommonPage from '@common/router/response/page';
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+export type TPageResponse<TRouter extends ClientRouter> = (
+    ClientResponse<TRouter, ClientPage>
+    |
+    ServerResponse<ServerRouter, ClientPage>
+);
+
+export type TRouterContext<TRouter extends ClientRouter = ClientRouter, TApplication extends ClientApplication = ClientApplication> = (
+    // ClientPage context
+    {
+        app: TApplication,
+        context: TRouterContext<TRouter, TApplication>,
+        request: ClientRequest<TRouter>,
+        route: TRoute<TRouter>,
+        api: ClientRequest<TRouter>["api"],
+        page: ClientPage<TRouter>,
+        user: User
+    }
+    &
+    // Expose client application services (api, socket, ...)
+    //TRouter["app"] 
+    TApplication
+)
+
+/*----------------------------------
+- ROUTER
+----------------------------------*/
+export default class ClientPageResponse<
+    TRouter extends ClientRouter,
+    TData extends TResponseData = TResponseData
+> extends BaseResponse<TData> {
+
+    public context: TRouterContext<TRouter, TRouter["app"]>;
+
+    public constructor(
+        public request: ClientRequest<TRouter>,
+        public route: TRoute | TErrorRoute,
+
+        public app = request.app,
+    ) {
+
+        super(request);
+
+        request.response = this;
+
+        // Create response context for controllers
+        this.context = this.createContext();
+    }
+
+    private createContext(): TRouterContext<TRouter, TRouter["app"]> {
+
+        const context: TRouterContext<TRouter, TRouter["app"]> = {
+            // App services (TODO: expose only services)
+            ...this.request.app,
+            // Router context
+            app: this.app,
+            context: undefined as unknown as TRouterContext<TRouter, TRouter["app"]>,
+            request: this.request,
+            route: this.route,
+            api: this.request.api,
+        }
+
+        context.context = context;
+
+        return context;
+    }
+
+    public async runController( additionnalData: {} = {} ): Promise<ClientPage> {
+
+        // Run contoller
+        const result = this.route.controller(this.context);
+
+        // Default data type for `return <raw data>`
+        if (result instanceof ClientPage)
+            await result.render();
+        else
+            throw new Error(`Unsupported response format: ${result.constructor?.name}`);
+
+        return result;
+    }
+
+    public redirect(url: string) {
+        history?.replace(url);
+    }
+}

package/src/client/services/router/response/page.ts

@@ -0,0 +1,95 @@
+/*----------------------------------
+- DEPENDANCES
+----------------------------------*/
+
+// Core
+import type { TClientOrServerContext } from '@common/router';
+import PageResponse, { TDataProvider, TFrontRenderer } from "@common/router/response/page";
+
+// Specific
+import type ClientRouter from '..';
+
+/*----------------------------------
+- TYPES
+----------------------------------*/
+
+
+
+/*----------------------------------
+- CLASS
+----------------------------------*/
+
+export default class ClientPage<TRouter = ClientRouter> extends PageResponse<TRouter> {
+
+    public isLoading: boolean = false;
+    public scrollToId: string;
+
+    public constructor(
+        public dataProvider: TDataProvider | null,
+        public component: TFrontRenderer,
+        public context: TClientOrServerContext,
+
+        public route = context.route
+    ) {
+
+        super(dataProvider, component, context);
+
+        this.bodyId = context.route.options.bodyId;
+        this.scrollToId = context.request.hash;
+    }
+    
+    public async render( data?: TObjetDonnees ) {
+
+        // Add the page to the context
+        this.context.page = this;
+         
+        // Load the fetchers list to load data if needed
+        if (this.dataProvider)
+            this.fetchers = this.dataProvider( this.context );
+
+        // Data succesfully loaded
+        if (data !== undefined) {
+            this.isLoading = false;
+            this.data = data;
+        }
+
+        // Fetch data
+        this.data = await this.fetchData();
+
+        return this;
+    }
+
+   /*----------------------------------
+    - ACTIONS
+    ----------------------------------*/
+    // Should be called AFTER rendering the page
+    public updateClient() {
+
+        document.body.id = this.bodyId || this.id;
+        document.title = this.title || APP_NAME;
+        document.body.className = [...this.bodyClass].join(' ');
+        
+    }
+
+    public setAllData( callback: (data: {[k: string]: any}) => void) { 
+        console.warn(`page.setAllData not yet attached to the page Reatc component.`); 
+    }
+    public setData( key: string, value: ((value: any) => void) | any ) {
+        this.setAllData(old => ({ 
+            ...old, 
+            [key]: typeof value === 'function' ? value(old[key]) : value 
+        }));
+    }
+
+    public loadIndicator;
+    public loading(state: boolean) {
+
+        if (state === true) {
+            if (!document.body.classList.contains("loading"))
+                document.body.classList.add("loading");
+        } else {
+            document.body.classList.remove("loading");
+        }
+
+    }
+}

package/src/client/{context/socket.ts → services/socket/index.ts}

@@ -2,7 +2,7 @@
 - DEPENDANCES
 ----------------------------------*/
 
-import type { ClientContext } from '.';
+import type { ClientContext } from '../../context';
 
 import type { TDialogControls } from '@client/components/Dialog/Manager';
 
@@ -131,7 +131,7 @@ export default class SocketClient {
 
     public scopes: { [name: string]: SocketScope } = {}
 
-    public constructor(public context: ClientContext ) {
+    public constructor( public context: ClientContext ) {
 
         
     }

package/src/client/utils/dom.ts

@@ -1,5 +1,5 @@
 import type { RefObject } from 'preact';
-import { history } from '@client/router/request/history';
+import { history } from '@client/services/router/request/history';
 
 type ElementOrSelector = HTMLElement | string;
 export const deepContains = (

package/src/common/app/index.ts

@@ -0,0 +1,9 @@
+import type ClientApplication from '@client/app';
+import type ServerApplication from '@server/app';
+
+export type ClientOrServerApplication = ClientApplication | ServerApplication;
+
+export type TAppArrowFunction<
+    TRegisteredData = void,
+    TApplication extends ClientOrServerApplication = ClientOrServerApplication
+> = (app: TApplication) => TRegisteredData

package/src/common/data/chaines/index.ts

@@ -11,6 +11,11 @@ export const nameToID = (name: string) => name.toLowerCase().replace(/[^a-z1-9]/
 
 export const ucfirst = (chaine: string): string => {
     return chaine.charAt(0).toUpperCase() + chaine.slice(1);
+} 
+
+export const linkify = (texte: string): string => {
+    const regex = /((http|https)\:\/\/([a-zA-Z0-9\-\.]+\.[a-zA-Z]{2,3}(\/\S*)?))/gi;
+    return texte.replace(regex, '<a href="$1" target="_blank">$3</a>');
 }
 
 export const trim = (s: string, c: string) => {
@@ -19,12 +24,7 @@ export const trim = (s: string, c: string) => {
     return s.replace(new RegExp(
         "^[" + c + "]+|[" + c + "]+$", "g"
     ), "");
-}   
-
-export const linkify = (texte: string): string => {
-    const regex = /((http|https)\:\/\/([a-zA-Z0-9\-\.]+\.[a-zA-Z]{2,3}(\/\S*)?))/gi;
-    return texte.replace(regex, '<a href="$1" target="_blank">$3</a>');
-}
+}  
 
 export const trimLeft = (chaine: string, toTrim: string) => chaine.startsWith(toTrim)
     ? chaine.substring(toTrim.length) : chaine;
@@ -32,6 +32,9 @@ export const trimLeft = (chaine: string, toTrim: string) => chaine.startsWith(to
 export const trimRight = (chaine: string, toTrim: string) => chaine.endsWith(toTrim)
     ? chaine.substring(0, -toTrim.length) : chaine;
 
+export const escapeRegExp = (string: string) =>
+    string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
+
 /*----------------------------------
 - EXTRACT
 ----------------------------------*/

package/src/common/data/input/validate.ts

@@ -24,53 +24,6 @@ const debug = false;
 
 //import type { Choix } from '@client/components/Champs/Base/Choix';
 
-export type TSchema = { [champ: string]: TSchema | TSchemaChampComplet }
-
-export type TSchemaChamp<TValeur> = {
-
-    rendu?: TBaseComposantChamp,
-    activer?: (donnees: TObjetDonnees) => boolean,
-    onglet?: string, // Sert juste d'identifiant secondaire. Ex: nom onglet correspondant
-
-    // Executé après le validateur propre au type
-    valider?: (val: TValeur, donneesSaisie: TObjetDonnees, donneesRetour: TObjetDonnees, corriger?: boolean) => Promise<TValeur>,
-    dependances?: string[],
-    opt?: true,
-    defaut?: TValeur,
-    as?: string[], // Mapping personnalisé
-
-}
-
-export type TBaseComposantChamp = (props: any) => ComponentChild;
-
-export type TSchemaChampComplet<TValeur = unknown> = TSchemaChamp<TValeur> & {
-    type: string,
-    valider: (val: any, formData?: unknown) => Promise<TValeur | undefined>
-}
-
-/*----------------------------------
-- TYPES: VALIDATION SCHEMA
-----------------------------------*/
-type TOptsValider = {
-    critique?: boolean,
-    validationComplete?: boolean,
-    avecDependances?: boolean,
-    corriger?: boolean,
-}
-
-export type TDonneesValidees<TSchemaA extends TSchema> = {
-    [cle in keyof TSchemaA]: TSchemaA[cle]["type"] extends string
-    // Champ
-    ? ThenArg<ReturnType<TSchemaA[cle]["valider"]>>
-    // Schema
-    : TDonneesValidees<TSchemaA[cle]>
-}
-
-export type TRetourValidation<TSchemaA extends TSchema> = {
-    valeurs: TDonneesValidees<TSchemaA>,
-    nbErreurs: number,
-    erreurs: TListeErreursSaisie
-}
 
 /*----------------------------------
 - FONCTIONS
@@ -81,10 +34,10 @@ export const initDonnees = <TSchemaA extends TSchema>(
     schema: TSchemaA,
     donnees: TObjetDonnees,
     toutConserver: boolean = false
-): Partial<TDonneesValidees<TSchemaA>> => {
+): Partial<TValidatedData<TSchemaA>> => {
 
     // toutConserver = true: on conserve toutes les données, y compris celles n'étant pas été définies dans le schéma
-    let retour: Partial<TDonneesValidees<TSchemaA>> = toutConserver ? { ...donnees } : {}
+    let retour: Partial<TValidatedData<TSchemaA>> = toutConserver ? { ...donnees } : {}
 
     for (const nomChamp in schema) {
         const elem = schema[nomChamp];
@@ -107,120 +60,4 @@ export const initDonnees = <TSchemaA extends TSchema>(
 
 }
 
-export const validate = async <TSchemaA extends TSchema, TDonnees extends TObjetDonnees>(
-
-    schema: TSchemaA,
-
-    inputAvalider: Partial<TDonnees>,
-    inputComplet?: TDonnees,
-    output: TObjetDonnees = {},
-
-    opts: TOptsValider = {},
-    chemin: string[] = []
-
-): Promise<TRetourValidation<TSchemaA>> => {
-
-    opts = {
-        critique: false,
-        validationComplete: false,
-        avecDependances: true,
-        corriger: false,
-        ...opts,
-    }
-
-    const clesAvalider = Object.keys(opts.validationComplete === true ? schema : inputAvalider);
-
-    let outputSchema = output;
-    for (const branche of chemin)
-        outputSchema = outputSchema[branche];
-
-    // Validation de chacune d'entre elles
-    let erreurs: TListeErreursSaisie = {};
-    let nbErreurs = 0;
-    for (const champ of clesAvalider) {
-
-        // La donnée est répertoriée dans le schema
-        const metas = schema[champ];
-        if (metas === undefined) {
-            debug && console.warn('[schema][valider][' + champ + ']', 'Exclusion (pas présent dans le schéma)');
-            continue;
-        }
-
-        const cheminA = [...chemin, champ].join('.')
-
-        // Sous-schema
-        if (isSchema(metas)) {
-
-            // Initialise la structure pour permettre l'assignement d'outputSchema
-            if (outputSchema[champ] === undefined)
-                outputSchema[champ] = {}
-
-            const validationSchema = await validate(
-                metas,
-                inputAvalider[champ],
-                inputComplet,
-                output,
-                opts,
-                cheminA
-            );
-            erreurs = { ...erreurs, ...validationSchema.erreurs };
-            nbErreurs += validationSchema.nbErreurs;
-
-            // Pas besoin d'assigner, car output est passé en référence
-            //output[champ] = validationSchema.valeurs;
-
-
-
-        } else if (metas.activer !== undefined && metas.activer(inputComplet) === false) {
-
-            delete outputSchema[champ];
-
-        } else {
-
-            // Champ composé de plusieurs valeurs
-            const valOrigine = metas.as === undefined
-                ? inputAvalider[champ]
-                // Le champ regroupe plusieurs valeurs (ex: Periode)
-                : metas.as.map((nomVal: string) => inputAvalider[nomVal])
-
-            // Validation
-            try {
-
-                const val = await metas.valider(valOrigine, inputComplet, output, opts.corriger);
-
-                // Exclusion seulement si explicitement demandé
-                // IMPORTANT: Conserver les valeurs undefined
-                //      La présence d'un valeur undefined peut être utile, par exemple, pour indiquer qu'on souhaite supprimer une donnée
-                //      Exemple: undefinec = suppression fichier | Absende donnée = conservation fihcier actuel
-                if (val === EXCLURE_VALEUR)
-                    debug && console.log('[schema][valider][' + cheminA + '] Exclusion demandée');
-                else
-                    outputSchema[champ] = val;
-
-                debug && console.log('[schema][valider][' + cheminA + ']', valOrigine, '=>', val);
-
-            } catch (error) {
-
-                debug && console.warn('[schema][valider][' + cheminA + ']', valOrigine, '|| Erreur:', error);
-
-                if (error instanceof Erreur) {
-
-                    // Référencement erreur
-                    erreurs[cheminA] = [error.message]
-                    nbErreurs++;
-
-                } else
-                    throw error;
-            }
-        }
-    }
-
-    if (nbErreurs !== 0 && opts.critique === true) {
-        throw new InputErrorSchema(erreurs);
-    }
-
-    debug && console.log('[schema][valider]', inputAvalider, '=>', output);
-
-    return { erreurs, nbErreurs, valeurs: output, };
-
-}
+export const validate = 

package/src/common/data/objets.ts

@@ -118,3 +118,28 @@ export const chemin = {
         
     }
 }
+
+export const callableInstance = <TInstance extends object, TCallableName extends keyof TInstance>(
+    instance: TInstance, 
+    funcName: TCallableName
+): TInstance[TCallableName] & TInstance => {
+
+    const callableFunc = instance[funcName];
+    if (typeof callableFunc !== 'function')
+        throw new Error(`instance[funcName] isn't callable.`);
+
+    const callable = callableFunc.bind(instance);
+
+    const methods = [
+        ...Object.getOwnPropertyNames( Object.getPrototypeOf( instance )),
+        ...Object.getOwnPropertyNames( instance )
+    ];
+
+    for (const method of methods)
+        if (method !== 'constructor')
+            callable[ method ] = typeof instance[ method ] === 'function'
+                ? instance[ method ].bind( instance )
+                : instance[ method ];
+
+    return callable as TInstance[TCallableName] & TInstance;
+}

package/src/common/data/tableaux.ts

@@ -40,6 +40,14 @@ export function arrayToObj<Ttbl extends {[cle: string]: any}, Tcle extends strin
 
 export const somme = (tbl: number[]) => tbl.reduce((a: number, b: number) => a + b);
 
+export const arrayChunks = <TArray extends any[]>(array: TArray, size: number) => {
+
+    const arrays: TArray[] = [];
+    while (array.length > 0)
+        arrays.push( array.splice(0, size) as TArray );
+
+    return arrays;
+}
 
 export function array_sum( tbl: number[] ): number {
     return tbl.reduce((a: number, b: number) => a + b);

package/src/common/errors/index.ts

@@ -161,4 +161,6 @@ export const instancierViaCode = (
         case 404: return new NotFound( message, details);
         default: return new Anomaly( message, details);
     }
-}
+}
+
+export default Erreur;