proteum 1.0.2 → 2.0.0

package/client/services/captcha/index.ts

@@ -1,67 +0,0 @@
-/*----------------------------------
-- DEPENDANCES
-----------------------------------*/
-
-// Npm
-import loadScript from 'load-script';
-
-/*----------------------------------
-- SERVICE
-----------------------------------*/
-export default class Recaptcha {
-
-    private idClientCaptcha: string | null = null;
-    public init(): Promise<void> {
-        const idConteneurBadge = 'badge-recaptcha';
-        return new Promise((resolve: Function, reject: Function) => {
-
-            // Déjà chargé
-            if (this.idClientCaptcha !== null)
-                return resolve();
-
-            loadScript('https://www.google.com/recaptcha/api.js?render=explicit', (err/*, script*/) => {
-                
-                if (err) {
-                    reject(err);
-                    return;
-                }
-
-                grecaptcha.ready(() => {
-
-                    const conteneur = document.getElementById(idConteneurBadge);
-
-                    if (!conteneur)
-                        throw new Error("Conteneur badge recaptcha pas trouvé");
-
-                    if (this.idClientCaptcha === null) {
-                        if (conteneur.dataset.flottant)
-                            this.idClientCaptcha = grecaptcha.render(idConteneurBadge, {
-                                'sitekey': this.app.apis.recaptcha.pub,
-                                'size': 'invisible'
-                            });
-                        else
-                            this.idClientCaptcha = grecaptcha.render(idConteneurBadge, {
-                                'sitekey': this.app.apis.recaptcha.pub,
-                                'badge': 'inline',
-                                'size': 'invisible'
-                            });
-                    }
-
-                    if (this.idClientCaptcha !== null)
-                        resolve();
-                    else
-                        reject("Attendez que la page soit complètement chargée. Si c'est déjà le cas, rechargez la page.");
-                });
-            })
-        });
-    }
-
-    public async check(action: string): Promise<string> {
-
-        await this.init();
-
-        const token = grecaptcha.execute(this.idClientCaptcha, { action: action });
-
-        return token;
-    }
-}

package/client/services/socket/index.ts

@@ -1,147 +0,0 @@
-/*----------------------------------
-- DEPENDANCES
-----------------------------------*/
-
-import type { ClientContext } from '../../context';
-
-import type { TDialogControls } from '@client/components/Dialog/Manager';
-
-/*----------------------------------
-- TYPE
-----------------------------------*/
-
-type TEventsList = {[name: string]: TEventCallback[]};
-
-type TEventCallback = (data: any) => void
-
-let netwokrStatusToast: TDialogControls;
-
-/*----------------------------------
-- SERVICE
-----------------------------------*/
-class SocketScope {
-
-    public ws?: WebSocket;
-    public events: TEventsList = {}
-
-    public constructor( 
-        public path: string, 
-        public context: ClientContext, 
-        events: {[name: string]: TEventCallback} = {} 
-    ) {
-        this.connect();
-
-        for (const event in events)
-            this.events[event] = [events[event]];
-    }
-    
-    private connect() {
-        
-        const protocol = window.location.protocol === 'http:' ? 'ws:' : 'wss:';
-        const url = protocol + '//' + this.context.request.host + this.path;
-
-        try {
-            this.ws = new WebSocket(url);
-        } catch (error) {
-            console.warn(`[socket] Connection failed for ${url}`, error);
-            return;
-        }
-
-        this.ws.onopen = () => {
-            console.log(`[socket] Connected to the live data provider:`, url);
-
-            if (netwokrStatusToast) {
-                netwokrStatusToast.close(true);
-                this.context.toast.success("Your connection has been restored", null, null, {
-                    autohide: 3
-                });
-            }
-        }
-
-        this.ws.onmessage = (event: MessageEvent<any>) => {
-
-            const [name, rawData] = event.data.split('>');
-            if (this.events[name] === undefined) {
-                console.warn("Unknown command: " + name + `. Raw command:`, event.data);
-                return;
-            }
-
-            let data;
-            try {
-                data = JSON.parse(rawData);
-            } catch (error) {
-                console.warn(`[socket] Error decoding data`, rawData, error);
-                return;
-            }
-
-            for (const callback of this.events[name])
-                callback(data);
-
-        }
-
-        this.ws.onerror = (event) => {
-            console.log(`[socket] Network error for ${url}`, event);
-            this.close();
-        }
-
-        this.ws.onclose = (event) => {
-
-            // Fermeture volontaire = on ne retente pas de se connecter
-            if (event.wasClean) {
-                console.log(`[socket] Disconnected from ${url}. Reason: `, event.reason);
-                return;
-            }
-
-            if (!netwokrStatusToast)
-                netwokrStatusToast = this.context.toast.error("You're offline", "Please check your connection", null, {
-                    autohide: false, 
-                    prison: true
-                });
-            console.log(`[socket] Disconnected from ${url}. Retry in 5 seconds ...`, event);
-            setTimeout(() => this.connect(), 5000);
-        }
-
-    }
-
-    public close() {
-        if (this.ws)
-            this.ws.close();
-    }
-
-    public on(event: string, callback: TEventCallback) {
-
-        if (this.events[event] === undefined)
-            this.events[event] = [callback]
-        else
-            this.events[event].push(callback)
-
-        return this;
-    }
-
-    public off(event: string) {
-
-        delete this.events[event];
-
-        return this;
-    }
-
-}
-
-export default class SocketClient {
-
-    public scopes: { [name: string]: SocketScope } = {}
-
-    public constructor( public context: ClientContext ) {
-
-        
-    }
-
-    public open(path: string, commands: {[name: string]: TEventCallback} = {}) {
-
-        if (!(path in this.scopes))
-            this.scopes[path] = new SocketScope(path, this.context, commands);
-
-        return this.scopes[path]
-    }
-
-}

package/common/data/rte/nodes.ts

@@ -1,83 +0,0 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- */
-
-import type { Klass, LexicalNode } from 'lexical';
-
-import { CodeHighlightNode, CodeNode } from '@lexical/code';
-import { HashtagNode } from '@lexical/hashtag';
-import { AutoLinkNode, LinkNode } from '@lexical/link';
-import { ListItemNode, ListNode } from '@lexical/list';
-import { MarkNode } from '@lexical/mark';
-import { OverflowNode } from '@lexical/overflow';
-import { HorizontalRuleNode } from '@lexical/react/LexicalHorizontalRuleNode';
-import { HeadingNode, QuoteNode } from '@lexical/rich-text';
-import { TableCellNode, TableNode, TableRowNode } from '@lexical/table';
-
-import { CollapsibleContainerNode } from '@client/components/Rte/plugins/CollapsiblePlugin/CollapsibleContainerNode';
-import { CollapsibleContentNode } from '@client/components/Rte/plugins/CollapsiblePlugin/CollapsibleContentNode';
-import { CollapsibleTitleNode } from '@client/components/Rte/plugins/CollapsiblePlugin/CollapsibleTitleNode';
-import { AutocompleteNode } from '@client/components/Rte/nodes/AutocompleteNode';
-import { EmojiNode } from '@client/components/Rte/nodes/EmojiNode';
-import { ImageNode } from '@client/components/Rte/nodes/ImageNode';
-import { InlineImageNode } from '@client/components/Rte/nodes/InlineImageNode/InlineImageNode';
-import { KeywordNode } from '@client/components/Rte/nodes/KeywordNode';
-import { LayoutContainerNode } from '@client/components/Rte/nodes/LayoutContainerNode';
-import { LayoutItemNode } from '@client/components/Rte/nodes/LayoutItemNode';
-import { MentionNode } from '@client/components/Rte/nodes/MentionNode';
-import { PageBreakNode } from '@client/components/Rte/nodes/PageBreakNode';
-import { PollNode } from '@client/components/Rte/nodes/PollNode';
-import { StickyNode } from '@client/components/Rte/nodes/StickyNode';
-import { TweetNode } from '@client/components/Rte/nodes/TweetNode';
-import { YouTubeNode } from '@client/components/Rte/nodes/YouTubeNode';
-
-import HeadingWithAnchorNode from '@client/components/Rte/nodes/HeadingNode';
-import ReferenceLinkNode from '@client/components/Rte/nodes/ReferenceLinkNode';
-
-const PlaygroundNodes: Array<Klass<LexicalNode>> = [
-    /*HeadingNode, */HeadingWithAnchorNode,
-    {
-        replace: HeadingNode,
-        with: (node) => {
-            return new HeadingWithAnchorNode( node.getTag() );
-        }
-    },
-    ListNode,
-    ListItemNode,
-    QuoteNode,
-    CodeNode,
-    TableNode,
-    TableCellNode,
-    TableRowNode,
-    HashtagNode,
-    CodeHighlightNode,
-    AutoLinkNode,
-    LinkNode,
-    OverflowNode,
-    PollNode,
-    StickyNode,
-    ImageNode, InlineImageNode,
-    MentionNode,
-    EmojiNode,
-    AutocompleteNode,
-    KeywordNode,
-    HorizontalRuleNode,
-    TweetNode,
-    YouTubeNode,
-    MarkNode,
-    CollapsibleContainerNode,
-    CollapsibleContentNode,
-    CollapsibleTitleNode,
-    PageBreakNode,
-    LayoutContainerNode,
-    LayoutItemNode,
-
-    // Custom
-    ReferenceLinkNode
-];
-
-export default PlaygroundNodes;

package/common/data/stats.ts

@@ -1,90 +0,0 @@
-import hInterval from 'human-interval';
-
-type TObjDonneesStats = { [cheminStats: string]: number }
-export type TStat<TDonnees extends TObjDonneesStats> = { date: string } & TDonnees
-export type TTimeStat<TDonnees extends TObjDonneesStats> = { time: number } & TDonnees
-
-/*----------------------------------
-- OUTILS DE TRAITEMENT
-----------------------------------*/
-type TRetourStats<TDonnees extends TObjDonneesStats> = {
-    graph: TTimeStat<TDonnees>[],
-    total: TDonnees,
-
-    start: Date,
-    end: Date,
-    interval: number,
-}
-
-export const buildStats = <TDonnees extends TObjDonneesStats>(
-    periodStr: string,
-    intervalStr: string,
-    data: TStat<TDonnees>[]
-): TRetourStats<TDonnees> => {
-
-    // NOTE: On ne génère pas le timestamp via la bdd pour éviter les incohérences de timezone
-
-    if (!Array.isArray(data)) {
-        console.log('data =', data);
-        throw new Error(`Stats data must be an array (received ${typeof data}). See console for full provided data.`);
-    }
-
-    const periodTime = hInterval(periodStr);
-    if (periodTime === undefined) throw new Error(`Invalid period string`);
-    const intervalTime = hInterval(intervalStr);
-    if (intervalTime === undefined) throw new Error(`Invalid interval string`);
-
-    let start = Date.now() - periodTime
-    start -= start % intervalTime; // Round start date to the specified interval
-    const end = Date.now()
-
-    const total: TDonnees = {} as TDonnees
-    let graph: TTimeStat<TDonnees>[] = []
-    if (data.length > 0) {
-
-        // Group data by time
-        const groups: { [timestamp: number]: TTimeStat<TDonnees> } = {};
-        for (const { date, ...stats } of data) {
-
-            if (date === undefined)
-                throw new Error(`La date est absente des données statistiques. Est-elle bien spécifiée dans le SELECT ?`);
-
-            const timeA = new Date(date).getTime();
-            groups[timeA] = { time: timeA, ...stats };
-        }
-
-        // Completion
-        for (let timeA = start; timeA <= end; timeA += intervalTime) {
-
-            const stats = { time: timeA, ...total }
-
-            if (groups[timeA] !== undefined)
-                for (const nom in groups[timeA]) {
-
-                    // numeric value only
-                    if (typeof groups[timeA][nom] !== 'number')
-                        continue;
-
-                    // Add cumulated value
-                    stats[nom] = stats[nom] === undefined
-                        ? groups[timeA][nom]
-                        : stats[nom] + groups[timeA][nom];
-
-                    total[nom] = stats[nom];
-
-                }
-
-            graph.push(stats);
-
-        }
-    }
-
-    return { 
-        graph, 
-        total, 
-        start: new Date(start), 
-        end: new Date(end),
-        interval: intervalTime
-    };
-
-}

package/common/utils/rte.ts

@@ -1,183 +0,0 @@
-
-import type Driver from '@server/services/disks/driver';
-import { Anomaly } from '@common/errors';
-
-export type LexicalNode = {
-    version: number,
-    type: string,
-    children?: LexicalNode[],
-    // Attachement
-    src?: string;
-    // Headhing
-    text?: string;
-    anchor?: string;
-    tag?: string;
-}
-
-export type LexicalState = {
-    root: LexicalNode
-}
-
-export type TRenderOptions = {
-
-    format?: 'html' | 'text', // Default = html
-    transform?: RteUtils["transformNode"],
-
-    render?: (
-        node: LexicalNode, 
-        parent: LexicalNode | null, 
-        options: TRenderOptions
-    ) => Promise<LexicalNode>,
-
-    attachements?: {
-        disk: Driver,
-        directory: string,
-        prevVersion?: string | LexicalState | null,
-    }
-}
-
-export type TSkeleton = { 
-    id: string,
-    title: string, 
-    level: number, 
-    childrens: TSkeleton 
-}[];
-
-export type TContentAssets = {
-    attachements: string[],
-    skeleton: TSkeleton
-}
-
-export default abstract class RteUtils {
-
-    public async render( 
-        content: string | LexicalState, 
-        options: TRenderOptions = {}
-    ): Promise<TContentAssets & {
-        html: string | null,
-        json: string | LexicalState,
-    }> {
-
-        // Transform content
-        const assets: TContentAssets = {
-            attachements: [],
-            skeleton: []
-        }
-
-        // Parse content if string
-        let json = this.parseState(content);
-        if (json === false)
-            return { html: '', json: content, ...assets }
-
-        // Parse prev version if string
-        if (typeof options?.attachements?.prevVersion === 'string') {
-            try {
-                options.attachements.prevVersion = JSON.parse(options.attachements.prevVersion) as LexicalState;
-            } catch (error) {
-                throw new Anomaly("Invalid JSON format for the given JSON RTE prev version.");
-            }
-        }
-
-        const root = await this.processContent(json.root, null, async (node, parent) => {
-            return await this.transformNode(node, parent, assets, options);
-        });
-
-        json = { ...json, root };
-
-        // Delete unused attachements
-        const attachementOptions = options?.attachements;
-        if (attachementOptions && attachementOptions.prevVersion !== undefined) {
-
-            await this.processContent(root, null, async (node) => {
-                return await this.deleteUnusedFile(node, assets, attachementOptions);
-            });
-        }
-
-        // Convert json to HTML
-        let html: string | null;
-        if (options.format === 'text')
-            html = await this.jsonToText( json.root );
-        else
-            html = await this.jsonToHtml( json, options );
-
-        return { html, json: content, ...assets };
-    }
-
-    private parseState( content: string | LexicalState ): LexicalState | false {
-
-        if (typeof content === 'string' && content.trim().startsWith('{')) {
-            try {
-                return JSON.parse(content) as LexicalState;
-            } catch (error) { 
-                throw new Anomaly("Invalid JSON format for the given JSON RTE content.");
-            }
-        } else if (content && typeof content === 'object' && content.root)
-            return content;
-        else
-            return false;
-        
-    }
-
-    protected jsonToText(root: LexicalNode): string {
-        let result = '';
-
-        function traverse(node: LexicalNode) {
-            switch (node.type) {
-                case 'text':
-                    // Leaf text node
-                    result += node.text ?? '';
-                    break;
-                case 'linebreak':
-                    // Explicit line break node
-                    result += '\n';
-                    break;
-                default:
-                    // Container or block node: dive into children if any
-                    if (node.children) {
-                        node.children.forEach(traverse);
-                    }
-                    // After finishing a block-level node, append newline
-                    if (isBlockNode(node.type)) {
-                        result += '\n';
-                    }
-                    break;
-            }
-        }
-
-        // Heuristic: treat these as blocks
-        function isBlockNode(type: string): boolean {
-            return [
-                'root',
-                'paragraph',
-                'heading',
-                'listitem',
-                'unorderedlist',
-                'orderedlist',
-                'quote',
-                'codeblock',
-                'table',
-            ].includes(type);
-        }
-
-        traverse(root);
-
-        // Trim trailing whitespace/newlines
-        return result.replace(/\s+$/, '');
-    }
-    
-    public abstract jsonToHtml( json: LexicalState, options: TRenderOptions ): Promise<string | null>;
-
-    protected abstract processContent( 
-        node: LexicalNode, 
-        parent: LexicalNode | null, 
-        callback: (node: LexicalNode, parent: LexicalNode | null) => Promise<LexicalNode>
-    ): Promise<LexicalNode>;
-
-    protected abstract transformNode( node: LexicalNode, parent: LexicalNode | null, assets: TContentAssets, options: TRenderOptions ): Promise<LexicalNode>;
-
-    protected abstract deleteUnusedFile( 
-        node: LexicalNode, 
-        assets: TContentAssets, 
-        options: NonNullable<TRenderOptions["attachements"]>
-    ): Promise<LexicalNode>;
-}