@edifice.io/client 2.1.0-develop-enabling.0 → 2.1.0-develop-b2school.20250204153130

package/dist/analytics/Service.d.ts

@@ -1,32 +1,8 @@
-import { IMatomoTrackingParams, ITrackingParams, IXitiTrackingParams } from '../configure/interfaces';
 import { IOdeServices } from '../services/OdeServices';
 import { IWebApp } from '../session/interfaces';
-export type XitiConf = {
-    ID_EXPLOITANT: string;
-    ID_PLATEFORME: string;
-    ID_PROJET: string;
-    active: boolean;
-    config: boolean;
-    structureMap?: {
-        [structureId: string]: {
-            UAI?: string;
-            active: boolean;
-            collectiviteId?: number;
-            plateformeId?: any;
-            projetId?: any;
-        };
-    };
-};
-export type ParamsByTrackingSystem = {
-    type: 'none' | 'internal' | 'matomo' | 'multiple';
-    internal?: ITrackingParams;
-    matomo?: IMatomoTrackingParams;
-    xiti?: IXitiTrackingParams;
-};
 export declare class AnalyticsService {
     private context;
     constructor(context: IOdeServices);
-    private get conf();
     private get http();
     private get session();
     /**

package/dist/apps/timeline/Framework.d.ts

@@ -0,0 +1,25 @@
+import { IFlashMessageModel, ITimelineApp } from './interfaces';
+import { Notification } from './Notification.model';
+export declare class TimelineApp implements ITimelineApp {
+    private _notifications;
+    private _notificationTypes;
+    private _flashMessages;
+    private _pageNumber;
+    private _lastPage;
+    private _loading;
+    showMine: boolean;
+    get notifications(): Array<Notification>;
+    get isLoading(): boolean;
+    get page(): number;
+    get hasMorePage(): boolean;
+    get notificationTypes(): Array<string>;
+    get selectedNotificationTypes(): Array<string>;
+    get preferences(): any;
+    get flashMessages(): IFlashMessageModel[];
+    savePreferences(): Promise<void>;
+    resetPagination(): void;
+    initialize(): Promise<void>;
+    loadNotifications(force?: boolean): Promise<void>;
+    loadFlashMessages(): Promise<void>;
+    markAsRead(msg: IFlashMessageModel): Promise<void>;
+}

package/dist/apps/timeline/Notification.model.d.ts

@@ -0,0 +1,10 @@
+import { ITimelineNotification, NotificationModel } from './interfaces';
+export declare class Notification implements ITimelineNotification {
+    constructor(model: NotificationModel);
+    _id: string;
+    model: NotificationModel;
+    isUnread(): boolean;
+    delete(): Promise<any>;
+    discard(): Promise<any>;
+    report(): Promise<any>;
+}

package/dist/apps/timeline/interfaces.d.ts

@@ -0,0 +1,69 @@
+export declare abstract class ITimelineFactory {
+    static createInstance(): ITimelineApp;
+}
+export interface ITimelineApp {
+    initialize(): Promise<void>;
+    readonly notificationTypes: Array<string>;
+    readonly selectedNotificationTypes: Array<string>;
+    showMine: boolean;
+    /** Load more notifications, or force loading more by virtually incrementing the page. */
+    loadNotifications(force?: boolean): Promise<void>;
+    readonly notifications: Array<ITimelineNotification>;
+    resetPagination(): void;
+    readonly isLoading: boolean;
+    readonly page: number;
+    readonly hasMorePage: boolean;
+    savePreferences(): Promise<void>;
+    readonly preferences: any;
+    loadFlashMessages(): Promise<void>;
+    readonly flashMessages: Array<IFlashMessageModel>;
+    markAsRead(msg: IFlashMessageModel): Promise<void>;
+}
+export interface ITimelineNotification {
+    readonly _id: string;
+    readonly model: NotificationModel;
+    isUnread(): boolean;
+    delete(): Promise<void>;
+    discard(): Promise<void>;
+    report(): Promise<void>;
+}
+export type NotificationModel = {
+    _id: string;
+    type: string;
+    eventType: string;
+    resource: string;
+    sender: string;
+    params: {
+        uri: string;
+        username: string;
+        blogTitle: string;
+        resourceUri: string;
+    };
+    date: {
+        $date: number;
+    };
+    message: string;
+    recipients?: Array<Recipient>;
+    reported?: boolean;
+    reporters?: any;
+};
+export interface Recipient {
+    userId: string;
+}
+export interface IFlashMessageModel {
+    readonly id: string;
+    readonly title?: string;
+    readonly contents?: object;
+    readonly startDate?: string;
+    readonly endDate?: string;
+    readonly readCount?: number;
+    readonly author?: string;
+    readonly profiles?: string[];
+    readonly color?: string;
+    readonly customColor?: string | null;
+    readonly lastModifier?: string;
+    readonly structureId?: string;
+    readonly subStructures?: string[];
+    readonly signature?: string;
+    readonly signatureColor?: string;
+}

package/dist/cache/Service.d.ts

@@ -1,5 +1,5 @@
-import { IHttpParams, IHttpResponse } from '../http/interfaces';
 import { IOdeServices } from '../services/OdeServices';
+import { IHttpParams, IHttpResponse } from '../transport/interfaces';
 export declare class CacheService {
     private context;
     constructor(context: IOdeServices);

package/dist/configure/Analytics.d.ts

@@ -0,0 +1,40 @@
+import { AnalyticStatus, IXitiTrackingParams, IMatomoTrackingParams, ITrackingParams, TrackingType } from './interfaces';
+export type ParamsByTrackingSystem = {
+    type: 'none' | 'internal' | 'matomo' | 'multiple';
+    internal?: ITrackingParams;
+    matomo?: IMatomoTrackingParams;
+    xiti?: IXitiTrackingParams;
+};
+export type XitiConf = {
+    ID_EXPLOITANT: string;
+    ID_PLATEFORME: string;
+    ID_PROJET: string;
+    active: boolean;
+    config: boolean;
+    structureMap?: {
+        [structureId: string]: {
+            UAI?: string;
+            active: boolean;
+            collectiviteId?: number;
+            plateformeId?: any;
+            projetId?: any;
+        };
+    };
+};
+export declare class Analytics {
+    private _status;
+    private _params?;
+    get status(): AnalyticStatus;
+    xiti(): Promise<IXitiTrackingParams | undefined>;
+    parameters<T extends ITrackingParams>(type: TrackingType): Promise<T | undefined>;
+    private parametersWithCheck;
+    /**
+     * This method loads the conf and waits for the user session to start.
+     * It can be called ASAP, but it will be automatically called if needed.
+     * @returns A promise of the end of the init process (it may throw errors)
+     * @throws ERROR_CODE.MALFORMED_DATA when config cannot be read.
+     */
+    private initialize;
+    /** 2021 implementation of XiTi. */
+    private initializeXiti;
+}

package/dist/configure/AppConf.d.ts

@@ -0,0 +1,17 @@
+import { App } from '../globals';
+import { IWebApp } from '../session/interfaces';
+export declare class AppConf {
+    private _publicConf;
+    private _currentApp?;
+    private _appConf;
+    /**
+     * Get the currently initialized App.
+     * @see getter SessionFramework.currentApp
+     */
+    get currentApp(): App | null;
+    setCurrentApp(app: App): AppConf;
+    initialize(app: App, alternativeApp?: boolean): Promise<void>;
+    getPublicConf(app: App): Promise<any>;
+    getWebAppConf(app: App): Promise<IWebApp | undefined>;
+    loadI18n(app: App): Promise<void>;
+}

package/dist/configure/Framework.d.ts

@@ -0,0 +1,22 @@
+import { IConfigurationFramework } from './interfaces';
+import { Theme } from './Theme';
+import { Idiom } from '../idiom/Idiom';
+import { User } from './User';
+import { AppConf } from './AppConf';
+import { Analytics } from './Analytics';
+export declare class ConfigurationFramework implements IConfigurationFramework {
+    readonly Platform: {
+        deploymentTag: string;
+        cdnDomain: string;
+        apps: AppConf;
+        theme: Theme;
+        analytics: Analytics;
+        idiom: Idiom;
+        listLanguages: () => Promise<any>;
+    };
+    readonly School: {};
+    readonly User: User;
+    initialize(version?: string | null, cdnDomain?: string | null): Promise<void>;
+}
+/** The whole framework is a singleton. */
+export declare const configure: ConfigurationFramework;

package/dist/configure/Service.d.ts

@@ -4,13 +4,10 @@ import { IGetConf } from './interfaces';
 export declare class ConfService {
     private context;
     constructor(context: IOdeServices);
-    readonly Platform: {
-        deploymentTag: string;
-        cdnDomain: string;
-    };
     private get http();
     private get cache();
     private get cdnDomain();
+    private get notify();
     getConf(app: App): Promise<IGetConf>;
     getPublicConf<T>(app: App): Promise<T>;
     getCdnUrl(): string | undefined;

package/dist/configure/Theme.d.ts

@@ -0,0 +1,34 @@
+import { ITheme, IThemeConf, IThemeDesc, IThemeOverrides, IThemeConfOverriding } from './interfaces';
+export declare class Theme implements ITheme {
+    private _conf?;
+    private _loaded?;
+    skinName: string;
+    themeName: string;
+    skin: string;
+    themeUrl: string;
+    templateOverrides: IThemeOverrides;
+    portalTemplate: string;
+    basePath: string;
+    logoutCallback: string;
+    skins: Array<IThemeConfOverriding>;
+    is1D: boolean;
+    is2D: boolean;
+    initialize(version?: string): Promise<void>;
+    private get version();
+    private get cdnDomain();
+    onFullyReady(): Promise<ITheme>;
+    private _onSkinReady;
+    onSkinReady(): Promise<ITheme>;
+    private _onOverrideReady;
+    onOverrideReady(): Promise<IThemeOverrides>;
+    getConf(version?: string): Promise<IThemeConf>;
+    load(version?: string): Promise<void>;
+    private loadDisconnected;
+    private loadConnected;
+    /** Load the user's configured theme. */
+    private loadDefaultTheme;
+    listThemes(): Promise<IThemeDesc[]>;
+    setDefaultTheme(theme: IThemeDesc): Promise<void>;
+    listSkins(): Promise<IThemeConfOverriding[]>;
+    getHelpPath(): Promise<string>;
+}

package/dist/configure/User.d.ts

@@ -0,0 +1,21 @@
+import { App } from '../globals';
+import { IUserPreferences } from './interfaces';
+import { IWebApp } from '../session/interfaces';
+export declare class User {
+    private _me;
+    private _keepOpenOnLogout;
+    private _preferences;
+    private _bookmarkedApps;
+    get keepOpenOnLogout(): boolean;
+    get preferences(): IUserPreferences;
+    get bookmarkedApps(): Array<IWebApp>;
+    initialize(version?: string): Promise<void>;
+    private setCurrentModel;
+    private loadPublicConf;
+    /** Bookmarks : pinned apps */
+    private loadBookmarks;
+    loadAppPrefs(app: App): Promise<any>;
+    saveAppPrefs(app: App): Promise<void>;
+    loadLanguage(): Promise<string>;
+    saveLanguage(lang: string): Promise<void>;
+}

package/dist/configure/interfaces.d.ts

@@ -1,5 +1,62 @@
 import { App, USER_PREFS } from '../globals';
 import { IWebApp } from '../session/interfaces';
+export declare abstract class ConfigurationFrameworkFactory {
+    static instance(): IConfigurationFramework;
+}
+export interface IConfigurationFramework {
+    /** Framework initialization */
+    initialize(version: string | null, cdnDomain: string | null): Promise<void>;
+    readonly Platform: {
+        readonly deploymentTag: string;
+        readonly cdnDomain: string;
+        readonly apps: {
+            /**
+             * Initialize an app (preload its public conf and i18n)
+             * @param app Which application to initialize
+             * @param alternativeApp Truthy when an application needs initializing another, while remaining principal.
+             */
+            initialize(app: App, alternativeApp?: boolean): Promise<void>;
+            /** Load and return the public conf of an app. */
+            getPublicConf(app: App): Promise<any>;
+            /** Load and return the server conf of an app. */
+            getWebAppConf(app: App): Promise<IWebApp | undefined>;
+            /** Load the i18n of an app. */
+            loadI18n(app: App): Promise<void>;
+        };
+        /** Configured theme. */
+        readonly theme: ITheme;
+        /** Configured tracking. */
+        readonly analytics: {
+            /** Get a tracker parameters. */
+            parameters<T extends ITrackingParams>(type: TrackingType): Promise<T | undefined>;
+            /**
+             * Get the XiTi configuration.
+             * This method awaits for the session to be be fully loaded.
+             * //FIXME refactor xiti configuration
+             */
+            xiti(): Promise<IXitiTrackingParams | undefined>;
+            /** Check the status, if something goes wrong. */
+            readonly status: AnalyticStatus;
+        };
+        /** I18n (port from legacy infra-front)*/
+        readonly idiom: IIdiom;
+        listLanguages(): Promise<string[]>;
+    };
+    readonly User: {
+        /** User's preferences.*/
+        readonly preferences: IUserPreferences;
+        /** Legacy option (//FIXME which use ?).*/
+        readonly keepOpenOnLogout: boolean;
+        /** User's prefered apps. */
+        readonly bookmarkedApps: Array<IWebApp>;
+        /** Load the user's preferences for the given app. */
+        loadAppPrefs(app: App): Promise<any>;
+        /** Save the user's preferences for the given app. */
+        saveAppPrefs(app: App): Promise<void>;
+        loadLanguage(): Promise<string>;
+        saveLanguage(lang: string): Promise<void>;
+    };
+}
 export type AnalyticStatus = 'void' | 'pending' | 'ready' | 'failed';
 export type TrackingType = 'matomo' | 'internal';
 export interface ITrackingParams {
@@ -72,7 +129,7 @@ export interface ITheme {
     /** List available skins. */
     listSkins(): Promise<IThemeConfOverriding[]>;
     /** Get the help path, which can be dedicated to 1D or 2D. */
-    getHelpPath(): Promise<String>;
+    getHelpPath(): Promise<string>;
 }
 export interface IThemeDesc {
     _id: string;
@@ -108,6 +165,27 @@ export type IThemeOverrides = {
     [app in App]?: string;
 };
 export type AddBundleCallback = () => void | Promise<void>;
+export interface IIdiom {
+    /** Get the translation of a given key.
+     * @param params (optional) map of key/value variables.
+     * @return the key itself when no translation exists.
+     */
+    translate(key: string, params?: {
+        [param: string]: any;
+    }): string;
+    /** Load a language bundle then return a Promise. */
+    addBundlePromise(path: string): Promise<void>;
+    /** Load a language bundle then call an optional callback. */
+    addBundle(path: string, callback?: AddBundleCallback): void;
+    /** Load the JSON language file from a given folder, using the current user's language, then call an optional callback. */
+    addTranslations(folder: string, callback?: AddBundleCallback): void;
+    /** Load the JSON language files from many given folders, using the current user's language, then return a Promise. */
+    addAllTranslations(folders: string[]): Promise<void>;
+    /** Add new key/values translations to the in-memory dictionary, using a key/value map. Existing in-memory keys ARE NOT REPLACED. Only new ones are added. */
+    addKeys(keys: any): void;
+    /** @return a new string without accentuation. */
+    removeAccents(str: string): string;
+}
 export type UserPreferenceKey = (typeof USER_PREFS)[keyof typeof USER_PREFS] | App;
 export interface IUserPreferences {
     data: {

package/dist/data/Service.d.ts

@@ -0,0 +1,25 @@
+import { DataServiceProps, IDataService } from './interface';
+import { IOdeServices } from '../services/OdeServices';
+/** Public conf of an app with a DataService activated. See backend /conf/public */
+export interface PublicConfForDataService {
+    'data-service'?: DataServiceProps;
+}
+export declare class DataService implements IDataService {
+    private odeServices;
+    private _webBroker?;
+    private app?;
+    private user?;
+    private profile?;
+    constructor(odeServices: IOdeServices);
+    private get conf();
+    private get notify();
+    initialize(): Promise<void>;
+    predestroy(): void;
+    /** Send a web-user-level event to the data pipeline. */
+    private trackWebEvent;
+    private addUserInfos;
+    trackVideoSave(video_id: string, duration: number, weight: number, isCaptation: boolean, url: string, browser: string, deviceType?: string): void;
+    trackVideoRead(video_id: string, isCaptation: boolean, url: string, browser: string, deviceType?: string): void;
+    trackSpeechAndText(direction: 'STT' | 'TTS'): void;
+    trackAccessLibraryFromExplorer(): void;
+}

package/dist/data/WebBroker.d.ts

@@ -0,0 +1,12 @@
+import { DataServiceProps, IEventBroker } from './interface';
+import { IOdeServices } from '../services/OdeServices';
+export declare class WebBroker implements IEventBroker {
+    private odeServices;
+    private subscription?;
+    constructor(odeServices: IOdeServices);
+    private get http();
+    private get events();
+    private dispatchEvent;
+    initialize(props: DataServiceProps['web'] | undefined): this;
+    destroy(): void;
+}

package/dist/data/interface.d.ts

@@ -0,0 +1,50 @@
+/** Joker value to permit sending all events. */
+export declare const SEND_ALL = "*";
+/** Data tracking service. */
+export interface IDataService {
+    /**
+     * Send a VIDEO_SAVE event to the backend.
+     * @param video_id ID of the workspace's video document.
+     * @param duration Duration of the video, in ms.
+     * @param weight Weight  of the video, in bytes.
+     * @param isCaptation Truthy is the video was captured on the end-user device.
+     * @param url Current URL of the navigator, when video was saved.
+     * @param browser Browser name and version (space-separated)
+     * @param deviceType @see UAParser.getDevice().type => console|mobile|tablet|smarttv|wearable|embedded
+     */
+    trackVideoSave(video_id: string, duration: number, weight: number, isCaptation: boolean, url: string, browser: string, deviceType?: string): void;
+    /**
+     * Send a VIDEO_READ event to the backend.
+     * @param video_id ID of the workspace's video document.
+     * @param isCaptation Truthy is the video was captured on the end-user device.
+     * @param url Current URL of the navigator, when video is played.
+     * @param browser Browser name and version (space-separated)
+     * @param deviceType @see UAParser.getDevice().type => console|mobile|tablet|smarttv|wearable|embedded
+     */
+    trackVideoRead(video_id: string, isCaptation: boolean, url: string, browser: string, deviceType?: string): void;
+    /**
+     * Send a SPEECH_AND_TEXT event to the backend.
+     * @param direction speech-to-text (voice recognition) or text-to-speech (voice generation)
+     */
+    trackSpeechAndText(direction: 'STT' | 'TTS'): void;
+    /**
+     * Send a ACCESS_LIBRARY_FROM_EXPLORER event to the backend.
+     */
+    trackAccessLibraryFromExplorer(): void;
+}
+/** Public properties of the DataService. */
+export interface DataServiceProps {
+    /** Parameters for web applications. */
+    web?: {
+        /**
+         * If defined, lists events to send to the backend (with "*" meaning all).
+         * If undefined, all events will be sent.
+         */
+        send?: Array<string | typeof SEND_ALL>;
+    };
+}
+/** An event broker for the DataService. */
+export interface IEventBroker {
+    /** Stops dispatching messages. */
+    destroy(): void;
+}

package/dist/globals.d.ts

@@ -25,11 +25,13 @@ export declare const APP: {
     readonly TIMELINE: "timeline";
     readonly WORKSPACE: "workspace";
     readonly EXPLORER: "explorer";
+    readonly HOMEWORKS: "homeworks";
     readonly VIDEO: "video";
     readonly MINDMAP: "mindmap";
     readonly SCRAPBOOK: "scrapbook";
     readonly COLLABORATIVEWALL: "collaborativewall";
     readonly WIKI: "wiki";
+    readonly TIMELINEGENERATOR: "timelinegenerator";
 };
 export type App = (typeof APP)[keyof typeof APP] | string;
 /**

package/dist/idiom/Idiom.d.ts

@@ -0,0 +1,18 @@
+import { AddBundleCallback, IIdiom } from '../configure/interfaces';
+export declare const defaultDiacriticsRemovalMap: {
+    base: string;
+    letters: RegExp;
+}[];
+export declare class Idiom implements IIdiom {
+    translate(key: string, params?: {
+        [param: string]: any;
+    }): string;
+    addBundlePromise(path: string): Promise<void>;
+    addBundle(path: string, callback?: AddBundleCallback): void;
+    loadBundlePromise(lang: string, path: string): Promise<void>;
+    private loadBundle;
+    addTranslations(folder: string, callback?: AddBundleCallback): void;
+    addAllTranslations(folders: string[]): Promise<void>;
+    addKeys(keys: any): void;
+    removeAccents(str: string): string;
+}

package/dist/idiom/Service.d.ts

@@ -1,4 +1,24 @@
+import { App } from '../globals';
+import { IOdeServices } from '../services/OdeServices';
+import { AddBundleCallback, IIdiom } from './interfaces';
 export declare const defaultDiacriticsRemovalMap: {
     base: string;
     letters: RegExp;
 }[];
+export declare class IdiomService implements IIdiom {
+    private context;
+    constructor(context: IOdeServices);
+    private get http();
+    getIdiom(currentLanguage: string, app: App): Promise<any>;
+    translate(key: string, params?: {
+        [param: string]: any;
+    }): string;
+    addBundlePromise(currentLanguage: string, path: string): Promise<void>;
+    addBundle(currentLanguage: string, path: string, callback?: AddBundleCallback): void;
+    loadBundlePromise(currentLanguage: string, path: string): Promise<void>;
+    private loadBundle;
+    addTranslations(folder: string, callback?: AddBundleCallback): void;
+    addAllTranslations(folders: string[]): Promise<void>;
+    addKeys(keys: any): void;
+    removeAccents(str: string): string;
+}