@edifice.io/client 2.0.1-develop-hotfix.1736863177286 → 2.0.1

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/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,8 @@
 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>;

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

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

package/dist/globals.d.ts

@@ -25,7 +25,6 @@ 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";

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;
+}