@edifice.io/client 1.7.4-develop-pedago.20241211160712

package/dist/configure/interfaces.d.ts

@@ -0,0 +1,218 @@
+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 School: {};
+    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 {
+    /** Whitelist of events to track, in the form "app" or "app.eventName" or "*.eventName". */
+    trackOnly: string[];
+    /** Blacklist of events not to track, in the form "app" or "app.eventName" or "*.eventName". */
+    doNotTrack: string[];
+    /** Set to true if state changes of the Single Page App need to be tracked. */
+    detailApps: boolean;
+}
+export interface IMatomoTrackingParams extends ITrackingParams {
+    url: string;
+    siteId: number;
+    UserId: string;
+    Profile: string;
+    School: string;
+    Project: string;
+}
+/** 2021 implementation of XiTi. */
+export interface IXitiTrackingParams {
+    /** Which property of LIBELLE_SERVICE to use depends on the frontend. */
+    LIBELLE_SERVICE: {
+        default: string;
+    } & {
+        [prop: string]: string;
+    };
+    TYPE: string;
+    OUTIL: any;
+    STRUCT_ID: any;
+    STRUCT_UAI: string;
+    PROJET: any;
+    EXPLOITANT: any;
+    PLATFORME: any;
+    ID_PERSO: any;
+    PROFILE: any;
+}
+export interface ITheme {
+    /** (legacy) Name of the currently active skin (user's choice in /timeline) : "default" by default, or another available name. */
+    readonly skinName: string;
+    /** (legacy) Name of the currently active theme, derived from a parent which is classified as 1D (panda) or 2D(theme-open-ent). This is a domain-level configurated value. */
+    readonly themeName: string;
+    /** (legacy) FIXME Seems to be equal to themeName. */
+    readonly skin: string;
+    /** (legacy) URL to the currently active theme/skin folder. */
+    readonly themeUrl: string;
+    /** (legacy) URL to the currently active portal.html template. Used in infra-front. */
+    readonly portalTemplate: string;
+    /** (legacy) URL to the folder containing assets. */
+    readonly basePath: string;
+    /** (legacy) URL where the user is redirected after logout. */
+    readonly logoutCallback: string;
+    /** Available skins configuration (also called "overrides"). */
+    readonly skins: Array<IThemeConfOverriding>;
+    /** Check if the "school degree" of the current theme is 1D ("panda", or an override of it). */
+    readonly is1D: boolean;
+    /** Check if the "school degree" of the current theme is 2D ("theme-open-ent" or an override of it). */
+    readonly is2D: boolean;
+    /** Get the theme/skin configuration. */
+    getConf(version?: string): Promise<IThemeConf>;
+    /** Await for theme to be fully loaded (skin, overrides, degrees...). */
+    onFullyReady(): Promise<ITheme>;
+    /** Await for skin conf to be loaded. */
+    onSkinReady(): Promise<ITheme>;
+    /** Await for overrides conf to be loaded. */
+    onOverrideReady(): Promise<IThemeOverrides>;
+    /** List available themes. */
+    listThemes(): Promise<IThemeDesc[]>;
+    /** Configure UI with this theme by default. */
+    setDefaultTheme(theme: IThemeDesc): void;
+    /** List available skins. */
+    listSkins(): Promise<IThemeConfOverriding[]>;
+    /** Get the help path, which can be dedicated to 1D or 2D. */
+    getHelpPath(): Promise<String>;
+}
+export interface IThemeDesc {
+    _id: string;
+    displayName: string;
+    path: string;
+}
+export interface IThemeConf {
+    dependencies: {
+        themes: {
+            [name: string]: string;
+        };
+        widgets: {
+            [name: string]: string;
+        };
+    };
+    emitWrapper: boolean;
+    overriding: Array<IThemeConfOverriding>;
+}
+export interface IThemeConfOverriding {
+    parent: 'panda' | 'theme-open-ent';
+    child: string;
+    bootstrapVersion: string;
+    skins: Array<string>;
+    help: string;
+    group?: string;
+    edumedia: {
+        uri: string;
+        pattern: string;
+        ignoreSubjects?: Array<string>;
+    };
+}
+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: {
+        [key in UserPreferenceKey]?: any;
+    };
+    get(key: UserPreferenceKey): any;
+    load(key: UserPreferenceKey, defaultTo?: any): Promise<any>;
+    update(key: UserPreferenceKey, data: any): IUserPreferences;
+    save(key: UserPreferenceKey): Promise<void>;
+}
+export interface IOdeTheme {
+    basePath: string;
+    bootstrapVersion: string;
+    is1d: boolean;
+    logoutCallback: string;
+    skin: string;
+    skinName: string;
+    skins: Array<IThemeConfOverriding>;
+    themeName: string;
+    themeUrl: string;
+    npmTheme: string | undefined;
+}
+export interface IGetConf {
+    app: App;
+    applications: IWebApp[];
+    conf: IThemeConf;
+    currentApp: IWebApp | undefined;
+    theme: IOdeTheme;
+}

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/directory/Service.d.ts

@@ -0,0 +1,17 @@
+import { IOdeServices } from '../services/OdeServices';
+import { Bookmark, BookmarkWithDetails, BookmarkWithMembers, Group, User } from './interface';
+export declare class DirectoryService {
+    private odeServices;
+    constructor(odeServices: IOdeServices);
+    private get http();
+    private get cache();
+    getAvatarUrl(id: string, type: 'user' | 'group', size?: string): string;
+    getDirectoryUrl(id: string, type: 'user' | 'group'): string;
+    getBookMarks(): Promise<Bookmark[]>;
+    getBookMarkById(idBookmark: string): Promise<BookmarkWithDetails>;
+    saveBookmarks(name: string, { bookmarks, groups, users, }: {
+        users: string[] | User[];
+        groups: string[] | Group[];
+        bookmarks: BookmarkWithMembers[] | string[];
+    }): Promise<BookmarkWithMembers>;
+}

package/dist/directory/interface.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Selected User when using directory routes
+ */
+export interface User {
+    id: string;
+    displayName: string;
+    profile: string;
+    lastName: string;
+    firstName: string;
+    login: string;
+}
+export interface Group {
+    id: string;
+    displayName: string;
+}
+/**
+ * Id and Name of Bookmark
+ */
+export interface Bookmark {
+    id: string;
+    displayName: string;
+}
+export interface BookmarkWithMembers extends Bookmark {
+    members: string[];
+}
+export interface BookmarkWithDetails extends Bookmark {
+    users: User[];
+    groups: Group[];
+}
+export interface BookmarkSaveResponse {
+    id: string;
+}
+/**
+ * Payload when getting bookamark info
+ */
+export interface BookmarkGetResponse {
+    id: string;
+    name: string;
+    groups: Array<{
+        id: string;
+        name: string;
+        activationCode: boolean;
+        groupType: string;
+        profile: string;
+        sortName: string;
+    }>;
+    users: Array<{
+        displayName: string;
+        profile: string;
+        id: string;
+        activationCode: boolean;
+    }>;
+}

package/dist/embedder/Service.d.ts

@@ -0,0 +1,39 @@
+import { IOdeServices } from '../services/OdeServices';
+import { Embedder } from './interface';
+export declare class EmbedderService {
+    private context;
+    constructor(context: IOdeServices);
+    private get http();
+    /**
+     * Returns the default list of video embedder
+     * @returns the default list of video embedder
+     */
+    getDefault(): Promise<Embedder[]>;
+    /**
+     * Returns the custom list of video embedder
+     * @returns the custom list of video embedder
+     */
+    getCustom(): Promise<Embedder[]>;
+    /**
+     * The provider matching with the URL
+     * @param {Embedder[]} embedderList - The list of video providers to test with
+     * @param {String} url - The URL for the video
+     * @returns The provider matching with the URL or undefined
+     */
+    getProviderFromUrl(embedderList: Embedder[], url: string): Embedder | undefined;
+    private urlIsFromPattern;
+    /**
+     * Check if a given URL correspond to one of the URL pattern of the provider
+     * @param {String} url - The URL for the video
+     * @param {Embedder} embedder - The video provider to test with
+     * @returns boolean depending if a given URL correspond to one of the URL pattern of the provider
+     */
+    private isUrlFromProvider;
+    /**
+     * Get embed code to display the video for an URL and a provider
+     * @param {Embedder} embedder - The video provider for the URL
+     * @param {String} url - The URL for the video
+     * @returns embed code to display the video for an URL and a provider
+     */
+    getEmbedCodeForProvider(embedder: Embedder, url: string): string;
+}

package/dist/embedder/interface.d.ts

@@ -0,0 +1,14 @@
+export type Embedder = {
+    /** Embedder name  */
+    name: string;
+    /** Embedder display name  */
+    displayName: string;
+    /** Embedder list of url  */
+    url: string[];
+    /** Embedder logo  */
+    logo: string;
+    /** Embedder embed  */
+    embed: string;
+    /** Embedder example  */
+    example: string;
+};

package/dist/globals.d.ts

@@ -0,0 +1,52 @@
+export declare const ERROR_CODE: {
+    readonly SUCCESS: "0000";
+    readonly UNKNOWN: "0010";
+    readonly NOT_INITIALIZED: "0020";
+    readonly NOT_SUPPORTED: "0030";
+    readonly APP_NOT_FOUND: "0040";
+    readonly AGENT_NOT_FOUND: "0050";
+    readonly TRANSPORT_ERROR: "0060";
+    readonly TIME_OUT: "0070";
+    readonly MALFORMED_DATA: "0080";
+    readonly NOT_LOGGED_IN: "0090";
+};
+export type ErrorCode = (typeof ERROR_CODE)[keyof typeof ERROR_CODE];
+export declare const APP: {
+    readonly ADMIN: "admin";
+    readonly ARCHIVE: "archive";
+    readonly AUTH: "auth";
+    readonly CAS: "cas";
+    readonly COMMUNICATION: "communication";
+    readonly CONVERSATION: "conversation";
+    readonly DIRECTORY: "directory";
+    readonly USERBOOK: "userbook";
+    readonly INFRA: "infra";
+    readonly PORTAL: "portal";
+    readonly TIMELINE: "timeline";
+    readonly WORKSPACE: "workspace";
+    readonly EXPLORER: "explorer";
+    readonly VIDEO: "video";
+    readonly MINDMAP: "mindmap";
+    readonly SCRAPBOOK: "scrapbook";
+    readonly COLLABORATIVEWALL: "collaborativewall";
+    readonly WIKI: "wiki";
+};
+export type App = (typeof APP)[keyof typeof APP] | string;
+/**
+ * An ID is a unique string in its applicable field.
+ */
+export type ID = string;
+/**
+ * Type of resource generated by an application.
+ * For example "folder", "blog", "mindmap"...
+ */
+export type ResourceType = string;
+export declare const USER_PREFS: {
+    readonly APPS: "apps";
+    readonly WIDGETS: "widgets";
+    readonly LANGUAGE: "language";
+    readonly AUTH_CONNECTOR_ACCESSED: "authenticatedConnectorsAccessed";
+    readonly CURSUS: "cursus";
+    readonly INFOTIP: "infotip";
+    readonly RGPD_COOKIES: "rgpdCookies";
+};

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

@@ -0,0 +1,24 @@
+import { AddBundleCallback, IIdiom } from './interfaces';
+import { IOdeServices } from '../services/OdeServices';
+import { App } from '../globals';
+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;
+}

package/dist/idiom/interfaces.d.ts

@@ -0,0 +1,22 @@
+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(currentLanguage: string, path: string): Promise<void>;
+    /** Load a language bundle then call an optional callback. */
+    addBundle(currentLanguage: string, 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;
+}