5htp-core 0.2.5 → 0.2.6-2

package/src/client/components/inputv3/date/react-daterange-picker.less

@@ -0,0 +1,112 @@
+.react-daterange-picker {
+    display: inline-flex;
+    position: relative;
+  }
+  
+  .react-daterange-picker,
+  .react-daterange-picker *,
+  .react-daterange-picker *:before,
+  .react-daterange-picker *:after {
+    -moz-box-sizing: border-box;
+    -webkit-box-sizing: border-box;
+    box-sizing: border-box;
+  }
+  
+  .react-daterange-picker--disabled {
+    background-color: #f0f0f0;
+    color: #6d6d6d;
+  }
+  
+  .react-daterange-picker__wrapper {
+    display: flex;
+    flex-grow: 1;
+    flex-shrink: 0;
+    align-items: center;
+    border: thin solid gray;
+  }
+  
+  .react-daterange-picker__inputGroup {
+    min-width: calc((4px * 3) + 0.54em * 8 + 0.217em * 2);
+    height: 100%;
+    flex-grow: 1;
+    padding: 0 2px;
+    box-sizing: content-box;
+  }
+  
+  .react-daterange-picker__inputGroup__divider {
+    padding: 1px 0;
+    white-space: pre;
+  }
+  
+  .react-daterange-picker__inputGroup__divider,
+  .react-daterange-picker__inputGroup__leadingZero {
+    display: inline-block;
+  }
+  
+  .react-daterange-picker__inputGroup__input {
+    min-width: 0.54em;
+    height: 100%;
+    position: relative;
+    padding: 0 1px;
+    border: 0;
+    background: none;
+    font: inherit;
+    box-sizing: content-box;
+    -webkit-appearance: textfield;
+    -moz-appearance: textfield;
+    appearance: textfield;
+  }
+  
+  .react-daterange-picker__inputGroup__input::-webkit-outer-spin-button,
+  .react-daterange-picker__inputGroup__input::-webkit-inner-spin-button {
+    -webkit-appearance: none;
+    -moz-appearance: none;
+    appearance: none;
+    margin: 0;
+  }
+  
+  .react-daterange-picker__inputGroup__input:invalid {
+    background: rgba(255, 0, 0, 0.1);
+  }
+  
+  .react-daterange-picker__inputGroup__input--hasLeadingZero {
+    margin-left: -0.54em;
+    padding-left: calc(1px + 0.54em);
+  }
+  
+  .react-daterange-picker__button {
+    border: 0;
+    background: transparent;
+    padding: 4px 6px;
+  }
+  
+  .react-daterange-picker__button:enabled {
+    cursor: pointer;
+  }
+  
+  .react-daterange-picker__button:enabled:hover .react-daterange-picker__button__icon,
+  .react-daterange-picker__button:enabled:focus .react-daterange-picker__button__icon {
+    stroke: #0078d7;
+  }
+  
+  .react-daterange-picker__button:disabled .react-daterange-picker__button__icon {
+    stroke: #6d6d6d;
+  }
+  
+  .react-daterange-picker__button svg {
+    display: inherit;
+  }
+  
+  .react-daterange-picker__calendar {
+    width: 350px;
+    max-width: 100vw;
+    z-index: 1;
+  }
+  
+  .react-daterange-picker__calendar--closed {
+    display: none;
+  }
+  
+  .react-daterange-picker__calendar .react-calendar {
+    border-width: thin;
+  }

package/src/client/components/inputv3/{string/index.tsx → index.tsx}

@@ -8,7 +8,7 @@ import { ComponentChild, JSX } from 'preact';
 import TextareaAutosize from 'react-textarea-autosize';
 
 // Core libs
-import { useInput, InputBaseProps } from '../base';
+import { useInput, InputBaseProps } from './base';
 
 /*----------------------------------
 - TYPES
@@ -25,7 +25,7 @@ export type Props = {
     inputRef?: React.Ref<HTMLInputElement>
 
     // Behavior
-    type?: 'email' | 'password' | 'longtext',
+    type?: 'email' | 'password' | 'longtext' | 'number',
     choice?: string[] | ((input: string) => Promise<string[]>),
 
     // Actions
@@ -93,6 +93,10 @@ export default ({
         prefix = prefix || <i src="text" />;
         Tag = 'textarea'//TextareaAutosize;
 
+    } else if (type === 'number') {
+
+        fieldProps.type = 'number';
+
     }
 
     // Auto suffix

package/src/client/pages/_messages/403.tsx

@@ -23,7 +23,7 @@ router.error( 403, ({ message, modal }) => {
     });
 
     return (
-        <div class="col pd-2">
+        <div class="card w-3-4 col al-center pd-2">
 
             <i src="times-circle" class="fg error xxl" />
 

package/src/client/pages/_messages/500.tsx

@@ -23,7 +23,7 @@ router.error( 500, ({ message }) => {
     });
 
     return (
-        <div class="col pd-2">
+        <div class="card w-3-4 col al-center pd-2">
 
             <i src="times-circle" class="fg error xxl" />
 

package/src/client/pages/bug.tsx

@@ -5,7 +5,7 @@
 import React from 'react';
 
 // Core components
-import { Button, String } from '@client/components';
+import { Button, Input } from '@client/components';
 import Card, { Props as CardProps } from '@client/components/Dialog/card';
 
 // Core libs
@@ -49,11 +49,11 @@ export default ({ ...self }: {} & CardProps) => {
 
             <p>What's the problem ?</p>
 
-            <String type="longtext" title="Description of the problem" value={observation} onChange={setObservation} />
+            <Input type="longtext" title="Description of the problem" value={observation} onChange={setObservation} />
 
             <p>What did you do just before the problem occurs ?</p>
 
-            <String type="longtext" title="How the problem occured ?" value={before} onChange={setBefore} />
+            <Input type="longtext" title="How the problem occured ?" value={before} onChange={setBefore} />
 
         </Card>
     )

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

@@ -89,16 +89,11 @@ export default class ApiClient implements ApiClientService {
                 fetcher.data = { ...(fetcher.data || {}), ...params };
 
             console.log("[api][reload]", id, fetcher.method, fetcher.path, fetcher.data);
-            const indicator = this.toast.loading("Loading ...");
 
             this.fetchAsync(fetcher.method, fetcher.path, fetcher.data).then((data) => {
 
                 this.set({ [id]: data });
 
-            }).finally(() => {
-
-                indicator.close(true);
-
             })
         }
     }

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

@@ -10,18 +10,129 @@ import { FileToUpload } from '@client/components/inputv3/file';
 - TYPES
 ----------------------------------*/
 
+function mergeObjects(object1, object2) {
+    return [object1, object2].reduce(function (carry, objectToMerge) {
+        Object.keys(objectToMerge).forEach(function (objectKey) {
+            carry[objectKey] = objectToMerge[objectKey];
+        });
+        return carry;
+    }, {});
+}
+
+function isArray(val) {
+
+    return ({}).toString.call(val) === '[object Array]';
+}
+
+function isJsonObject(val) {
+
+    return !isArray(val) && typeof val === 'object' && !!val && !(val instanceof Blob) && !(val instanceof Date);
+}
+
+function isAppendFunctionPresent(formData) {
+
+    return typeof formData.append === 'function';
+}
+
+function isGlobalFormDataPresent() {
+
+    return typeof FormData === 'function';
+}
+
+function getDefaultFormData() {
+
+    if (isGlobalFormDataPresent()) {
+        return new FormData();
+    }
+}
+
+function convertRecursively(jsonObject, options, formData, parentKey) {
+
+    var index = 0;
+
+    for (var key in jsonObject) {
+
+        if (jsonObject.hasOwnProperty(key)) {
+
+            var propName = parentKey || key;
+            var value = options.mapping(jsonObject[key]);
+
+            if (parentKey && isJsonObject(jsonObject)) {
+                propName = parentKey + '[' + key + ']';
+            }
+
+            if (parentKey && isArray(jsonObject)) {
+
+                if (isArray(value) || options.showLeafArrayIndexes ) {
+                    propName = parentKey + '[' + index + ']';
+                } else {
+                    propName = parentKey + '[]';
+                }
+            }
+
+            // Exract the file object from value
+            if (typeof value === 'object' && value instanceof FileToUpload)
+                value = value.data;
+
+            if (isArray(value) || isJsonObject(value)) {
+
+                convertRecursively(value, options, formData, propName);
+
+            } else if (value instanceof FileList) {
+
+                for (var j = 0; j < value.length; j++) {
+                    formData.append(propName + '[' + j + ']', value.item(j));
+                }
+            } else if (value instanceof Blob) {
+
+                formData.append(propName, value, value.name);
+
+            } else if (value instanceof Date) {
+
+                formData.append(propName, value.toISOString());
+
+            } else if (((value === null && options.includeNullValues) || value !== null) && value !== undefined) {
+
+                formData.append(propName, value);
+            }
+        }
+        index++;
+    }
+    return formData;
+}
+
 /*----------------------------------
 - UTILS
 ----------------------------------*/
-export const toMultipart = (postData: TPostData) => {
-
-    const formData = new FormData();
-    for (const key in postData) {
-        let data = postData[key];
-        if (typeof data === 'object' && (data instanceof FileToUpload))
-            data = data.data;
-        formData.append(key, data);
+/* Based on https://github.com/hyperatom/json-form-data
+    Changes:
+    - Add support for FileToUpload
+*/
+export const toMultipart = (jsonObject: TPostData, options) => {
+
+    if (options && options.initialFormData) {
+        
+        if (!isAppendFunctionPresent(options.initialFormData)) {
+            throw 'initialFormData must have an append function.';
+        }
+    } else if (!isGlobalFormDataPresent()) {
+
+        throw 'This environment does not have global form data. options.initialFormData must be specified.';
     }
 
-    return formData;
+    var defaultOptions = {
+        initialFormData: getDefaultFormData(),
+        showLeafArrayIndexes: true,
+        includeNullValues: false,
+        mapping: function(value) {
+            if (typeof value === 'boolean') {
+                return +value ? '1': '0';
+            }
+            return value;
+        }
+    };
+
+    var mergedOptions = mergeObjects(defaultOptions, options || {});
+
+    return convertRecursively(jsonObject, mergedOptions, mergedOptions.initialFormData);
 }

package/src/client/utils/dom.ts

@@ -47,7 +47,7 @@ export const blurable = (...args: [HTMLElement, Function][]) => {
 
             if (!deepContains([refElement], e.target))
                 masquer();
-
+                
         }
     }
 
@@ -65,4 +65,15 @@ export const blurable = (...args: [HTMLElement, Function][]) => {
         window.removeEventListener('mousedown', blur);
         unlisten();
     }
+}
+
+export const focusContent = ( container: HTMLElement ) => {
+
+    const toFocus = container.querySelector(
+        'input, textarea, button.btn.primary, footer > button.btn'
+    ) || container;
+
+    console.log('Element to focus', toFocus);
+    // TODO: Type only docusable elemnts
+    toFocus?.focus();
 }

package/src/common/validation/schema.ts

@@ -18,18 +18,18 @@ type TSchemaOptions = {
     opt?: boolean
 }
 
-type TOptsValider = {
+export type TValidateOptions<TFields extends TSchemaFields = {}> = {
     debug?: boolean,
     throwError?: boolean,
-
-    validateAll?: boolean,
+    ignoreMissing?: boolean,
+    only?: (keyof TFields)[],
     validateDeps?: boolean,
     autoCorrect?: boolean,
 }
 
 export type TValidationResult<TFields extends TSchemaFields> = {
     values: TValidatedData<TFields>,
-    nbErreurs: number,
+    errorsCount: number,
     erreurs: TListeErreursSaisie
 }
 
@@ -62,7 +62,7 @@ export default class Schema<TFields extends TSchemaFields> {
         allData: TDonnees,
         output: TObjetDonnees = {},
     
-        opts: TOptsValider = {},
+        opts: TValidateOptions<TFields> = {},
         chemin: string[] = []
     
     ): TValidationResult<TFields> {
@@ -70,45 +70,44 @@ export default class Schema<TFields extends TSchemaFields> {
         opts = {
             debug: false,
             throwError: false,
-            validateAll: false,
             validateDeps: true,
             autoCorrect: false,
             ...opts,
         }
     
-        const clesAvalider = Object.keys(opts.validateAll === true ? this.fields : dataToValidate);
-    
         let outputSchema = output;
         for (const branche of chemin)
             outputSchema = outputSchema[branche];
+
+        const keysToValidate = opts.only || Object.keys(this.fields);
     
         // Validation de chacune d'entre elles
         let erreurs: TListeErreursSaisie = {};
-        let nbErreurs = 0;
-        for (const champ of clesAvalider) {
+        let errorsCount = 0;
+        for (const fieldName of keysToValidate) {
     
             // La donnée est répertoriée dans le schema
-            const field = this.fields[champ];
+            const field = this.fields[fieldName];
             if (field === undefined) {
-                opts.debug && console.warn(LogPrefix, '[' + champ + ']', 'Exclusion (pas présent dans le schéma)');
+                opts.debug && console.warn(LogPrefix, '[' + fieldName + ']', 'Exclusion (pas présent dans le schéma)');
                 continue;
             }
 
-            const cheminA = [...chemin, champ]
+            const cheminA = [...chemin, fieldName]
             const cheminAstr = cheminA.join('.')
     
             // Sous-schema
             if (field instanceof Schema) {
     
                 // Initialise la structure pour permettre l'assignement d'outputSchema
-                if (outputSchema[champ] === undefined)
-                    outputSchema[champ] = {}
+                if (outputSchema[fieldName] === undefined)
+                    outputSchema[fieldName] = {}
 
                 // The corresponding data should be an object
-                const schemadata = dataToValidate[champ];
+                const schemadata = dataToValidate[fieldName];
                 if (typeof schemadata !== 'object') {
                     erreurs[ cheminAstr ] = [`Should be an object`];
-                    nbErreurs++;
+                    errorsCount++;
                     continue;
                 }
     
@@ -123,30 +122,30 @@ export default class Schema<TFields extends TSchemaFields> {
                     cheminA
                 );
                 erreurs = { ...erreurs, ...validationSchema.erreurs };
-                nbErreurs += validationSchema.nbErreurs;
+                errorsCount += validationSchema.errorsCount;
     
                 // Pas besoin d'assigner, car output est passé en référence
-                //output[champ] = validationSchema.values;
+                //output[fieldName] = validationSchema.values;
     
     
             // I don't remind what is options.activer about
             /*} else if (field.activer !== undefined && field.activer(allData) === false) {
     
-                delete outputSchema[champ];*/
+                delete outputSchema[fieldName];*/
     
             // Validator
             } else {
     
                 // Champ composé de plusieurs values
                 const valOrigine = field.options.as === undefined
-                    ? dataToValidate[champ]
-                    // Le champ regroupe plusieurs values (ex: Periode)
+                    ? dataToValidate[fieldName]
+                    // Le fieldName regroupe plusieurs values (ex: Periode)
                     : field.options.as.map((nomVal: string) => dataToValidate[nomVal])
     
                 // Validation
                 try {
     
-                    const val = field.validate(valOrigine, allData, output, opts.autoCorrect);
+                    const val = field.validate(valOrigine, allData, output, opts);
     
                     // Exclusion seulement si explicitement demandé
                     // IMPORTANT: Conserver les values undefined
@@ -155,7 +154,7 @@ export default class Schema<TFields extends TSchemaFields> {
                     if (val === EXCLUDE_VALUE)
                         opts.debug && console.log(LogPrefix, '[' + cheminA + '] Exclusion demandée');
                     else
-                        outputSchema[champ] = val;
+                        outputSchema[fieldName] = val;
     
                     opts.debug && console.log(LogPrefix, '[' + cheminA + ']', valOrigine, '=>', val);
     
@@ -167,7 +166,7 @@ export default class Schema<TFields extends TSchemaFields> {
     
                         // Référencement erreur
                         erreurs[cheminAstr] = [error.message]
-                        nbErreurs++;
+                        errorsCount++;
     
                     } else
                         throw error;
@@ -175,7 +174,7 @@ export default class Schema<TFields extends TSchemaFields> {
             }
         }
     
-        if (nbErreurs !== 0 && opts.throwError === true) {
+        if (errorsCount !== 0 && opts.throwError === true) {
             throw new InputErrorSchema(erreurs);
         }
         
@@ -184,7 +183,7 @@ export default class Schema<TFields extends TSchemaFields> {
         return { 
             values: output as TValidatedData<TFields>,
             erreurs, 
-            nbErreurs, 
+            errorsCount, 
         };
     
     }

package/src/common/validation/validator.ts

@@ -8,6 +8,9 @@ import type { ComponentChild } from 'preact'
 // Core
 import { InputError } from '@common/errors';
 
+// Specific
+import type { TValidateOptions } from './schema';
+
 /*----------------------------------
 - TYPES
 ----------------------------------*/
@@ -41,12 +44,12 @@ type TValidationArgs<TValue, TAllValues extends {}> = [
     val: TNonEmptyValue, 
     input: TAllValues, 
     output: Partial<TAllValues>, 
-    corriger?: boolean
+    validateOptions?: TValidateOptions
 ]
 
 type TValidationFunction<TValue, TAllValues extends {} = {}> = (
     ...args: TValidationArgs<TValue, TAllValues>
-    ) => TValue | typeof EXCLUDE_VALUE;
+) => TValue | typeof EXCLUDE_VALUE;
 
 type TValidateReturnType<
     TOptions extends TValidator<TValue>, 
@@ -76,12 +79,18 @@ export default class Validator<TValue, TOptions extends TValidator<TValue> = TVa
 
     public isEmpty = (val: any) => val === undefined || val === '' || val === null
 
-    public validate(...[ val, input, output, correct ]: TValidationArgs<TValue, {}>): TValidateReturnType<TOptions, TValue> {
+    public validate(...[ 
+        val, input, output, validateOptions 
+    ]: TValidationArgs<TValue, {}>): TValidateReturnType<TOptions, TValue> {
 
         // Required value
         if (this.isEmpty(val)) {
             // Optionnel, on skip
-            if (this.options.opt === true)
+            if (this.options.opt === true || (
+                validateOptions?.ignoreMissing === true
+                &&
+                val === undefined
+            ))
                 return undefined as TValidateReturnType<TOptions, TValue>;
             // Requis
             else
@@ -89,7 +98,7 @@ export default class Validator<TValue, TOptions extends TValidator<TValue> = TVa
         }
 
         // Validate type
-        return this.validateType(val, input, output, correct) as TValidateReturnType<TOptions, TValue>;
+        return this.validateType(val, input, output, validateOptions) as TValidateReturnType<TOptions, TValue>;
     }
 
 }

package/src/server/app/index.ts

@@ -180,6 +180,7 @@ export default abstract class Application extends Service<Config, Hooks, /* TODO
         for (const service of this.servicesList) {
             const serviceClassName = service.constructor?.name;
             console.log(`[app] Start service`, serviceClassName);
+            service.status = 'starting';
 
             if (service.register)
                 service.register();
@@ -191,8 +192,16 @@ export default abstract class Application extends Service<Config, Hooks, /* TODO
             // Start service
             if (service.start) {
                 service.started = service.start();
-                await service.started;
+                await service.started.catch(e => {
+                    console.error("Catched error while starting service " + serviceClassName + '. Exiting process if mode production.', e);
+                    if (this.env.profile === 'prod')
+                        process.exit();
+                    else
+                        throw e;
+                })
             }
+
+            service.status = 'running';
         }
 
         console.log(`[app] All ${this.servicesList.length} services were started.`);

package/src/server/app/service.ts

@@ -41,6 +41,7 @@ export default abstract class Service<
 
     public priority: TPriority = 0;
     public started?: Promise<void>;
+    public status: 'stopped' | 'starting' | 'running' | 'paused' = 'stopped';
 
     public commands?: Command[];