5htp-core 0.5.9-3 → 0.5.9-4

package/client/assets/css/components/mantine.less

@@ -24,6 +24,13 @@
     --number-input-height-md: @sizeComponent;
 }
 
+.mantine-SegmentedControl-root {
+    --segmented-control-height-md: @sizeComponent;
+    --mantine-SegmentedControl-height: @sizeComponent;
+}
+
+
+
 
 
 /*----------------------------------

package/client/components/Input.tsx

@@ -58,6 +58,7 @@ export default (initProps: Props) => {
     let Component: typeof TextInput | typeof NumberInput | typeof Textarea;
     if (props.type === 'number') {
         Component = NumberInput;
+        props.min = props.min ?? 0;
     } else if (props.type === 'longtext' && typeof document !== 'undefined') {
         Component = Textarea;
         props.autosize = true;

package/client/components/Select.tsx

@@ -102,8 +102,13 @@ export default (initProps: Props) => {
     React.useEffect(() => {
 
         if (choicesViaFunc && opened) {
+
+            const keywords = search.keywords === current?.label 
+                ? undefined 
+                : search.keywords;
+
             //setSearch(s => ({ ...s, loading: true }));
-            initChoices(search.keywords).then((searchResults) => {
+            initChoices(keywords).then((searchResults) => {
                 //setSearch(s => ({ ...s, loading: false }))
                 setChoices(searchResults);
             })
@@ -113,7 +118,7 @@ export default (initProps: Props) => {
 
     }, [
         opened,
-        //search.keywords,
+        search.keywords,
         // When initChoices is a function, React considers it's always different
         // It avoids the choices are fetched everytimle the parent component is re-rendered
         typeof initChoices === 'function' ? true : initChoices
@@ -130,6 +135,10 @@ export default (initProps: Props) => {
         props.onChange = (value: string) => onChange( valueToChoice(value) );
     }   
 
+    if (props.placeholder === 'Where the candidate will work ?') {
+        console.log('----------', props, choices);
+    }
+
     /*----------------------------------
     - RENDER
     ----------------------------------*/

package/client/services/router/components/router.tsx

@@ -191,7 +191,6 @@ export default ({ service: clientRouter, loaderComponent }: TProps) => {
         // Reset scroll
         window.scrollTo(0, 0);
         // Should be called AFTER rendering the page (so after the state change)
-        console.log("CHANGE PAGE", currentPage);
         currentPage?.updateClient();
         // Scroll to the selected content via url hash
         restoreScroll(currentPage);

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

@@ -21,7 +21,7 @@ import FileToUpload from '@client/components/File/FileToUpload';
 - TYPES
 ----------------------------------*/
 
-const debug = true;
+const debug = false;
 
 export type Config = {
 
@@ -86,7 +86,7 @@ export default class ApiClient implements ApiClientService {
         else if (typeof ids === 'string')   
             ids = [ids];
 
-        console.log("[api] Reload data", ids, params, page.fetchers);
+        debug && console.log("[api] Reload data", ids, params, page.fetchers);
 
         for (const id of ids) {
 
@@ -97,7 +97,7 @@ export default class ApiClient implements ApiClientService {
             if (params !== undefined)
                 fetcher.data = { ...(fetcher.data || {}), ...params };
 
-            console.log("[api][reload]", id, fetcher.method, fetcher.path, fetcher.data);
+            debug && console.log("[api][reload]", id, fetcher.method, fetcher.path, fetcher.data);
 
             this.fetchAsync(fetcher.method, fetcher.path, fetcher.data).then((data) => {
 
@@ -227,7 +227,7 @@ export default class ApiClient implements ApiClientService {
 
             } else if (options.encoding === 'multipart') {
 
-                console.log("[api] Multipart request", data);
+                debug && console.log("[api] Multipart request", data);
                 // Browser will automatically choose the right headers
                 config.body = toMultipart(data);
 

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "5htp-core",
 	"description": "Convenient TypeScript framework designed for Performance and Productivity.",
-	"version": "0.5.9-3",
+	"version": "0.5.9-4",
 	"author": "Gaetan Le Gac (https://github.com/gaetanlegac)",
 	"repository": "git://github.com/gaetanlegac/5htp-core.git",
 	"license": "MIT",

package/server/app/commands.ts

@@ -48,7 +48,7 @@ export type Services = {
 /*----------------------------------
 - SERVICE
 ----------------------------------*/
-export default class CommandsManager extends Service<Config, Hooks, Application, Services> {
+export default class CommandsManager extends Service<Config, Hooks, Application> {
 
     public priority = 2 as 2;
 

package/server/app/container/console/index.ts

@@ -376,7 +376,7 @@ export default class Console {
             logs
         }
 
-        await application.reportBug( bugReport );
+        await application.runHook('bug', bugReport);
     }
 
     public getChannel() {

package/server/app/container/index.ts

@@ -2,8 +2,6 @@
 - DEPENDANCES
 ----------------------------------*/
 
-import './patch';
-
 // Npm
 import path from 'path';
 

package/server/app/index.ts

@@ -99,7 +99,7 @@ export abstract class Application<
 
         // Application itself doesnt have configuration
         // Configuration must be handled by application services
-        super(self, {}, () => ({}), self);
+        super(self, {}, self);
         
         // Handle unhandled crash
         this.on('error', (e, request) => this.container.handleBug(e, "An error occured in the application", request));
@@ -138,6 +138,9 @@ export abstract class Application<
 
         this.startServices();
 
+        console.log('----------------------------------');
+        console.log('- SERVICES');
+        console.log('----------------------------------');
         await this.ready();
         await this.runHook('ready');
 
@@ -150,71 +153,41 @@ export abstract class Application<
     - ERROR HANDLING
     ----------------------------------*/
 
-    // Default error handler
-    public async reportBug( bug: ServerBug ) {
-
-        console.error( bug.error );
-
-    }
-
     private startServices() {
-
-        // Print services
-        console.log('----------------------------------');
-        console.log('- SERVICES');
-        console.log('----------------------------------');
-        const printService = (service, level: number = 0) => {
-
-            console.log('-' + '-'.repeat(level * 4), service.name, '(' + service.priority + ')');
-
-            if (service.subservices) for (const subservice of service.subservices)
-                printService(subservice, level + 1);
-        }
         
         // Satrt services
         for (const serviceId in this.registered) {
 
             const service = this.registered[serviceId];
-            printService(service, 0);
             const instance = service.start();
             this[service.name] = instance.getServiceInstance();
-            this[service.name].status = 'starting';
         }
     }
 
+    public register( service: AnyService ) {
+
+        service.ready();
+
+    }
+
     protected async ready() {
 
-        const processService = (service: AnyService) => {
+        // Print services
+        const processService = (propKey: string, service: AnyService, level: number = 0) => {
 
             if (service.status !== 'starting')
                 return;
 
             service.ready();
             service.status = 'running';
-            
-            // Subservices
-            for (const serviceId in service.services) {
-
-                const subservice = service.services[serviceId];
-                if (!subservice) {
-                    console.error(`Subservice ${serviceId} has not been initialised correctly in ${service.constructor.name}`, service.services);
-                    continue;
-                }
+            console.log('-' + '-'.repeat(level * 1), propKey + ': ' + service.constructor.name);
 
-                processService(subservice);
-            }
-        }
-
-        for (const serviceId in this.registered) {
-
-            const registeredService = this.registered[serviceId];
-            const service = this[registeredService.name];
-
-            // TODO: move to router
-            //  Application.on('service.ready')
+            // Routes
             const routes = service.__routes;
             if (routes) for (const route of routes) { 
 
+                console.log('Attached service', service.constructor.name, 'to route', route.path);
+
                 const origController = route.controller;
                 route.controller = (context: RouterContext) => {
 
@@ -232,8 +205,37 @@ export abstract class Application<
 
                 this.Router.controllers[ route.path ] = route;
             }
+            
+            // Subservices
+            for (const propKey in service) {
+
+                if (propKey === 'app')
+                    continue;
+                const propValue = service[propKey];
+
+                // Check if service
+                const isService = 
+                    typeof propValue === 'object' && 
+                    !(propValue instanceof Application) &&
+                    propValue !== null && 
+                    propValue.status !== undefined;
+                if (!isService)
+                    continue;
+
+                processService(propKey, propValue, level + 1);
+            }
+        }
+
+        for (const serviceId in this.registered) {
+
+            const registeredService = this.registered[serviceId];
+            const service = this[registeredService.name];
+
+            // TODO: move to router
+            //  Application.on('service.ready')
+            
 
-            processService(service);
+            processService(serviceId, service);
         }
     }
 

package/server/app/service/index.ts

@@ -13,11 +13,7 @@ import type { TControllerDefinition, TRoute } from '../../services/router';
 ----------------------------------*/
 
 export type AnyService<TSubServices extends StartedServicesIndex = StartedServicesIndex> = 
-    Service<{}, {}, Application, TSubServices>
-
-type TServiceConfig = {
-    priority?: number
-}
+    Service<{}, {}, Application>
 
 export type { TRegisteredServicesIndex, TRegisteredService } from './container';
 
@@ -41,9 +37,11 @@ export type StartedServicesIndex = {
     [serviceId: string]: AnyService
 }
 
-type TServiceUseOptions = {
-    optional?: boolean
-}
+export type TServiceArgs<TService extends AnyService> = [
+    parent: TService | 'self',
+    getConfig: (instance: TService) => {},
+    app: TService['app'] | 'self'
+]
 
 /*----------------------------------
 - CONFIG
@@ -51,7 +49,7 @@ type TServiceUseOptions = {
 
 const LogPrefix = '[service]';
 
-export function Route(options: TControllerDefinition = {}) {
+export function Route(options: Omit<TControllerDefinition, 'controller'> = {}) {
     return function (
         target: any,
         propertyKey: string,
@@ -90,30 +88,24 @@ export function Route(options: TControllerDefinition = {}) {
 - CLASS
 ----------------------------------*/
 export default abstract class Service<
-    TConfig extends TServiceConfig, 
+    TConfig extends {}, 
     THooks extends THooksList,
-    TApplication extends Application,
-    TServicesIndex extends StartedServicesIndex = {}
+    TApplication extends Application
 > {
 
     public started?: Promise<void>;
-    public status: 'stopped' | 'starting' | 'running' | 'paused' = 'stopped';
+    public status: 'stopped' | 'starting' | 'running' | 'paused' = 'starting';
 
     public commands?: Command[];
     public metas!: TServiceMetas;
     public bindings: string[] = []
 
     public app: TApplication;
+    public config: TConfig = {} as TConfig;
 
-    public constructor( 
-        public parent: AnyService | 'self', 
-        public config: TConfig,
-        // Make this argument appear as instanciated sercices index
-        // But actually, Setup.use returns a registered service, not yet launched
-        getServices: (instance: AnyService) => TServicesIndex,
-        app: TApplication | 'self'
-    ) {
+    public constructor(...[parent, getConfig, app]: TServiceArgs<AnyService>) {
 
+        this.parent = parent;
         if (this.parent === 'self') 
             this.parent = this;
 
@@ -121,8 +113,8 @@ export default abstract class Service<
             ? this as unknown as TApplication
             : app
 
-        if (typeof getServices === 'function')
-            this.services = getServices(this);
+        if (typeof getConfig === 'function')
+            this.config = getConfig(this);
         
     }
 
@@ -130,8 +122,6 @@ export default abstract class Service<
         return this;
     }
 
-    public services: TServicesIndex = {} as TServicesIndex;
-
     /*----------------------------------
     - LIFECYCLE
     ----------------------------------*/

package/server/services/auth/router/index.ts

@@ -37,12 +37,12 @@ export default class AuthenticationRouterService<
     - LIFECYCLE
     ----------------------------------*/
 
-    public users;
+    public users: UsersService;
 
     public constructor(...args) {
         super(...args);
 
-        this.users = this.services.users;
+        this.users = this.config.users;
     }
 
     protected async ready() {
@@ -51,7 +51,7 @@ export default class AuthenticationRouterService<
         this.parent.on('request', async (request: TRequest) => {
 
             // TODO: Typings. (context.user ?)
-            const decoded = await this.services.users.decode( request.req, true);
+            const decoded = await this.users.decode( request.req, true);
 
             request.user = decoded || null;
         })
@@ -61,7 +61,7 @@ export default class AuthenticationRouterService<
 
             if (route.options.auth !== undefined)
                 // TODO: How to pas the router type to router config ? Circular rfeerence ?
-                this.services.users.check(request, route.options.auth);
+                this.users.check(request, route.options.auth);
         })
     }
 

package/server/services/cache/index.ts

@@ -59,20 +59,17 @@ type TCacheGetOnlyArgs = [
 export type Config = {
     debug: boolean,
     disk: string, // TODO: keyof disks
+    disks: DisksManager
 }
 
 export type Hooks = {
 
 }
 
-export type Services = {
-    disks: DisksManager,
-}
-
 /*----------------------------------
 - SERVICE
 ----------------------------------*/
-export default class Cache extends Service<Config, Hooks, Application, Services> {
+export default class Cache extends Service<Config, Hooks, Application> {
 
     public commands = registerCommands(this);
 
@@ -83,13 +80,12 @@ export default class Cache extends Service<Config, Hooks, Application, Services>
     public constructor( 
         parent: AnyService, 
         config: Config,
-        services: Services,
         app: Application, 
     ) {
 
-        super(parent, config, services, app);
+        super(parent, config, app);
 
-        this.disk = this.services.disks.get(config.disk)
+        this.disk = this.config.disks.get(config.disk)
     }
 
     /*----------------------------------

package/server/services/cron/index.ts

@@ -36,7 +36,7 @@ export type Services = {
 - CLASSE
 ----------------------------------*/
 
-export default class CronManager extends Service<Config, Hooks, Application, Services> {
+export default class CronManager extends Service<Config, Hooks, Application> {
 
     public static taches: { [nom: string]: CronTask } = {}
     public static timer: NodeJS.Timeout;

package/server/services/database/index.ts

@@ -91,20 +91,19 @@ const emptyOkPacket = {
 
 // TODO: build callable instance sithut instanciating the service
 
-export default class SQL extends Service<Config, Hooks, Application, Services> {
+export default class SQL extends Service<Config, Hooks, Application> {
 
     public database: Database;
 
     public constructor( 
         parent: AnyService, 
         config: Config,
-        drivers: () => TRegisteredServicesIndex,
         app: Application, 
     ) {
 
-        super(parent, config, drivers, app);
+        super(parent, config, app);
 
-        this.database = new Database(this, config);
+        this.database = new Database(this, this.config);
     }
 
     public getServiceInstance() {

package/server/services/disks/driver.ts

@@ -56,7 +56,7 @@ export type TReadFileOptions = {
 export default abstract class FsDriver<
     Config extends TDrivercnfig = TDrivercnfig,
     TBucketName = keyof Config["buckets"]
-> extends Service<Config, {}, Application, Services> {
+> extends Service<Config, {}, Application> {
 
     public abstract mount(): Promise<void>;
 

package/server/services/disks/index.ts

@@ -17,6 +17,9 @@ export type { default as Driver } from './driver';
 type Config = {
     debug: boolean,
     default: string,//keyof MountpointList,
+    drivers: {
+        [driverId: string]: Driver
+    }
 }
 
 export type Hooks = {
@@ -34,12 +37,10 @@ export default class DisksManager<
     MountpointList extends Services = {},
     TConfig extends Config = Config,
     TApplication extends Application = Application
-> extends Service<TConfig, Hooks, TApplication, MountpointList> {
+> extends Service<TConfig, Hooks, TApplication> {
 
     public default!: Driver;
 
-    public mounted: MountpointList = this.services;
-
     /*----------------------------------
     - LIFECYCLE
     ----------------------------------*/
@@ -47,13 +48,12 @@ export default class DisksManager<
     public constructor( 
         parent: AnyService, 
         config: TConfig,
-        services: () => TRegisteredServicesIndex,
         app: Application, 
     ) {
 
-        super(parent, config, services, app);
+        super(parent, config, app);
 
-        const drivers = this.services;
+        const drivers = this.config.drivers;
         
         if (Object.keys( drivers ).length === 0)
             throw new Error("At least one disk driver should be mounted.");
@@ -78,7 +78,7 @@ export default class DisksManager<
 
         const disk = diskName == 'default' || diskName === undefined
             ? this.default 
-            : this.mounted[diskName];
+            : this.config.drivers[diskName];
 
         if (disk === undefined)
             throw new Error(`Disk "${diskName as string}" not found.`);

package/server/services/email/index.ts

@@ -31,6 +31,9 @@ export type Config = {
     bugReport: {
         from: TPerson,
         to: TPerson
+    },
+    transporters: {
+        [transporterId: string]: Transporter
     }
 }
 
@@ -106,9 +109,9 @@ type TOptions = {
 /*----------------------------------
 - FONCTIONS
 ----------------------------------*/
-export default class Email extends Service<Config, Hooks, Application, Services> {
+export default class Email extends Service<Config, Hooks, Application> {
     
-    private transporters = this.services;
+    private transporters = this.config.transporters;
 
     /*----------------------------------
     - ACTIONS

package/server/services/fetch/index.ts

@@ -26,18 +26,16 @@ import type FsDriver from '../disks/driver';
 
 export type Config = {
     debug?: boolean,
-    disk?: string
+    disk?: string,
+
+    disks: DisksManager,
+    router?: RouterService
 }
 
 export type Hooks = {
 
 }
 
-export type Services = {
-    disks: DisksManager,
-    router?: RouterService
-}
-
 /*----------------------------------
 - TYPES
 ----------------------------------*/
@@ -60,14 +58,14 @@ const LogPrefix = `[services][fetch]`
 - SERVICE
 -  Tools that helps to consume external resources (including apis, ..)
 -----------------------------------*/
-export default class FetchService extends Service<Config, Hooks, Application, Services> {
+export default class FetchService extends Service<Config, Hooks, Application> {
 
     private disk?: FsDriver;
 
     public async ready() {
 
-        if (this.services.disks)
-            this.disk = this.services.disks.get( this.config.disk );
+        if (this.config.disks)
+            this.disk = this.config.disks.get( this.config.disk );
 
     }
 
@@ -97,10 +95,10 @@ export default class FetchService extends Service<Config, Hooks, Application, Se
     ) {
 
         // Parse url if router service is provided
-        if (this.services.router === undefined)
+        if (this.config.router === undefined)
             throw new Error(`Please bind the Router service to the Fetch service in order to contact APIs.`);
 
-        url = this.services.router.url(url);
+        url = this.config.router.url(url);
 
         // Send request
         const res = await got(url, {

package/server/services/prisma/index.ts

@@ -34,7 +34,7 @@ export type Services = {
 - CLASSE
 ----------------------------------*/
 
-export default class ModelsManager extends Service<Config, Hooks, Application, Services> {
+export default class ModelsManager extends Service<Config, Hooks, Application> {
 
     public client = new PrismaClient();
   

package/server/services/router/index.ts

@@ -96,10 +96,10 @@ export type Config<
         request: ServerRequest<ServerRouter>, 
         app: Application
     ) => TAdditionnalSsrData,
-}
 
-export type Services = {
-    [routerServiceId: string]: RouterService
+    plugins: {
+        [routerServiceId: string]: RouterService
+    }
 }
 
 // Set it as a function, so when we instanciate the services, we can callthis.router to pass the router instance in roiuter services
@@ -129,7 +129,6 @@ export default class ServerRouter<
     // Services
     public http: HTTP;
     public render: DocumentRenderer<this>;
-    protected routerServices: TSubservices = {} as TSubservices
 
     // Indexed
     public routes: TRoute[] = []; // API + pages front front
@@ -147,13 +146,12 @@ export default class ServerRouter<
     public constructor( 
         parent: AnyService, 
         config: Config,
-        services: () => TSubservices,
         app: Application, 
     ) {
 
-        super(parent, config, services, app);
+        super(parent, config, app);
 
-        this.http = new HTTP(config.http, this);
+        this.http = new HTTP(this.config.http, this);
         this.render = new DocumentRenderer(this);
     }
 
@@ -164,11 +162,8 @@ export default class ServerRouter<
     public async ready() {
 
         // Detect router services
-        for (const serviceName in this.services) {
-
-            const routerService = this.services[serviceName];
-            if (routerService instanceof RouterService)
-                this.routerServices[ serviceName ] = routerService;
+        for (const serviceName in this.config.plugins) {
+            this.app.register( this.config.plugins[serviceName] )
         }
 
          // Use require to avoid circular references
@@ -326,10 +321,6 @@ export default class ServerRouter<
 
     private async afterRegister() {
 
-        // Generate typescript typings
-        if (this.app.env.profile === 'dev')
-            this.genTypings();
-
         // Ordonne par ordre de priorité
         this.config.debug && console.info("Loading routes ...");
         this.routes.sort((r1, r2) => {
@@ -393,21 +384,6 @@ export default class ServerRouter<
         this.config.debug && console.info(this.routes.length + " routes where registered.");
     }
 
-    private genTypings() {
-        /*fs.outputFileSync( path.join(this.app.path.typings, 'routes.d.ts'), `
-declare type Routes = {
-        ${this.routes.map( route => `
-            '${route.path}': {
-                params: {
-                    ${route.keys.map( k => "'" + k + "': string").join(',\n')}
-                }
-            }
-        `).join(',')}
-    }
-}
-        `);*/
-    }
-
     /*----------------------------------
     - RESOLUTION
     ----------------------------------*/
@@ -475,10 +451,11 @@ declare type Routes = {
     public createContextServices( request: ServerRequest<this> ) {
 
         const contextServices: Partial<TRouterContextServices<this>> = {}
-        for (const serviceName in this.routerServices) {
+        for (const serviceName in this.config.plugins) {
 
-            const routerService = this.routerServices[serviceName];
+            const routerService = this.config.plugins[serviceName];
             const requestService = routerService.requestService( request );
+
             if (requestService !== null)
                 contextServices[ serviceName ] = requestService;
 

package/server/services/router/service.ts

@@ -28,11 +28,10 @@ export default abstract class RouterService<
         //      It's fixed with a not very clean way in Service.bindService
         router: Router, 
         config: TConfig,
-        services: TRegisteredServicesIndex,
         app: Application
     ) {
 
-        super(router, config, services, app);
+        super(router, config, app);
         
     }
 

package/server/services/socket/index.ts

@@ -26,30 +26,27 @@ export type Config<TUser extends {}> = {
     //server: ServerOptions["server"],
     //users: UsersManagementService<TUser>,
     port: number,
+
+    users: UsersManagementService<TUser, Application>,
+    router: Router
 }
 
 export type Hooks = {
 
 }
 
-export type Services<TUser extends {}> = {
-    users: UsersManagementService<TUser, Application>,
-    router: Router
-}
-
 /*----------------------------------
 - MANAGER
 ----------------------------------*/
 export default class WebSocketCommander<
     TUser extends {},
-    TConfig extends Config<TUser>= Config<TUser>,
-    TServices extends Services<TUser> = Services<TUser>
-> extends Service<TConfig, Hooks, Application, TServices> {
+    TConfig extends Config<TUser>= Config<TUser>
+> extends Service<TConfig, Hooks, Application> {
 
     // Services
     public ws!: WebSocketServer;
-    public users!: TServices["users"];
-    public router!: Router;
+    public users!: TConfig["users"];
+    public router!: TConfig["router"];
 
     // Context
     public scopes: {[path: string]: SocketScope<TUser>} = {}
@@ -57,13 +54,12 @@ export default class WebSocketCommander<
     public constructor(
         parent: AnyService, 
         config: TConfig,
-        services: Services,
         app: TApplication, 
     ) {
-        super(parent, config, services, app);
+        super(parent, config, app);
         
-        this.users = this.services.users;
-        this.router = this.services.router;
+        this.users = this.config.users;
+        this.router = this.config.router;
         
     }
     

package/types/global/utils.d.ts

@@ -90,14 +90,12 @@ declare module '@cli/app' {
         setup: (...args: [
             // { user: app.setup('Core/User') }
             servicePath: string,
-            serviceConfig?: {},
-            serviceSubservices?: TServiceSubservices
+            serviceConfig?: {}
         ] | [
             // app.setup('User', 'Core/User')
             serviceName: string, 
             servicePath: string,
-            serviceConfig?: {},
-            serviceSubservices?: TServiceSubservices
+            serviceConfig?: {}
         ]) => TServiceSetup;
     }
     const app: App;

package/types/icons.d.ts

@@ -1 +1 @@
-export type TIcones = "solid/spinner-third"|"at"|"bell"|"times-circle"|"info-circle"|"check-circle"|"exclamation-circle"|"times"|"map-marker-alt"|"bullhorn"|"angle-down"|"search"|"check"|"arrow-left"|"arrow-right"|"eye"|"trash"|"meh-rolling-eyes"|"unlink"|"pen"|"bold"|"italic"|"underline"|"strikethrough"|"subscript"|"superscript"|"code"|"link"|"file"|"plus"|"font"|"empty-set"|"horizontal-rule"|"page-break"|"image"|"table"|"poll"|"columns"|"sticky-note"|"caret-right"|"align-left"|"align-center"|"align-right"|"align-justify"|"indent"|"outdent"|"list-ul"|"check-square"|"h1"|"h2"|"h3"|"h4"|"list-ol"|"paragraph"|"quote-left"
+export type TIcones = "long-arrow-right"|"times"|"solid/spinner-third"|"sack-dollar"|"bell"|"bullseye"|"project-diagram"|"user-friends"|"eye"|"lock"|"comments"|"phone"|"chalkboard-teacher"|"rocket"|"chart-bar"|"planet-ringed"|"crosshairs"|"user-circle"|"brands/linkedin"|"plus-circle"|"comments-alt"|"arrow-right"|"user-shield"|"shield-alt"|"chart-line"|"money-bill-wave"|"star"|"link"|"file-alt"|"long-arrow-left"|"key"|"user"|"at"|"user-plus"|"mouse-pointer"|"thumbs-up"|"dollar-sign"|"times-circle"|"calendar-alt"|"paper-plane"|"search"|"lightbulb"|"magnet"|"solid/crown"|"brands/discord"|"pen"|"plus"|"file"|"angle-up"|"angle-down"|"envelope"|"binoculars"|"info-circle"|"check-circle"|"exclamation-circle"|"meh-rolling-eyes"|"check"|"trash"|"arrow-left"|"solid/star"|"solid/star-half-alt"|"regular/star"|"chevron-left"|"cog"|"power-off"|"bars"|"plane-departure"|"wind"|"play"|"minus-circle"|"external-link"|"question-circle"|"usd-circle"|"users"|"home-alt"|"trophy"|"arrow-to-bottom"|"map-marker-alt"|"clock"|"ellipsis-h"|"building"|"bold"|"italic"|"underline"|"strikethrough"|"subscript"|"superscript"|"code"|"unlink"|"font"|"empty-set"|"horizontal-rule"|"page-break"|"image"|"table"|"poll"|"columns"|"sticky-note"|"caret-right"|"list-ul"|"check-square"|"h1"|"h2"|"h3"|"h4"|"list-ol"|"paragraph"|"quote-left"|"align-left"|"align-center"|"align-right"|"align-justify"|"indent"|"outdent"

package/server/app/container/patch.ts

@@ -1,15 +0,0 @@
-/*----------------------------------
-- DATES & TIMZEONE
-----------------------------------*/
-process.env.TZ = 'Europe/Paris';
-
-// https://www.npmjs.com/package/javascript-time-ago#intl
-import IntlPolyfill from 'intl'
-const locales = ['en'];
-if (typeof Intl === 'object') {
-    if (!Intl.DateTimeFormat || Intl.DateTimeFormat.supportedLocalesOf(locales).length !== locales.length) {
-        Intl.DateTimeFormat = IntlPolyfill.DateTimeFormat
-    }
-} else {
-    global.Intl = IntlPolyfill
-}