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

package/dist/notify/Framework.d.ts

@@ -0,0 +1,29 @@
+import { IGetConf, ITheme, IThemeOverrides } from '../configure/interfaces';
+import { IUserInfo } from '../session/interfaces';
+import { Subject } from './Subject';
+import { IPromisified, INotifyFramework } from './interfaces';
+/** Utility class */
+export declare class Promisified<T> implements IPromisified<T> {
+    private _resolution?;
+    private _rejection?;
+    private _promise;
+    get promise(): Promise<T>;
+    resolve(value: T | PromiseLike<T>): void;
+    reject(reason?: any): void;
+}
+/** The notify framework implementation. */
+declare class NotifyFramework implements INotifyFramework {
+    private promises;
+    private subject;
+    private asyncData;
+    onSessionReady(): IPromisified<IUserInfo>;
+    onLangReady(): IPromisified<string>;
+    onSkinReady(): Promisified<ITheme>;
+    onOverridesReady(): Promisified<IThemeOverrides>;
+    onAppConfReady(): Promisified<IGetConf>;
+    promisify<T>(): IPromisified<T>;
+    events(): Subject;
+}
+/** The whole framework is a singleton. */
+export declare const notify: NotifyFramework;
+export {};

package/dist/notify/Subject.d.ts

@@ -0,0 +1,9 @@
+import { IHttpErrorEvent, ISubject, ISubjectMessage, ISubscription, LayerName } from './interfaces';
+export declare class Subject implements ISubject {
+    private publishChannels;
+    private getChannelName;
+    private getPublishChannel;
+    newChannel(layer: string): BroadcastChannel;
+    publish(layer: LayerName, message: ISubjectMessage | IHttpErrorEvent): void;
+    subscribe<T extends ISubjectMessage>(layer: LayerName, handler: (message: T) => void): ISubscription;
+}

package/dist/notify/interfaces.d.ts

@@ -0,0 +1,113 @@
+import { IGetConf, ITheme, IThemeOverrides } from '../configure/interfaces';
+import { IUserInfo } from '../session/interfaces';
+import { IHttpParams, IHttpResponse } from '../transport/interfaces';
+export declare abstract class NotifyFrameworkFactory {
+    static instance(): INotifyFramework;
+}
+export interface INotifyFramework {
+    /**
+     * Notify that a process is done and data ready or rejected.
+     * Utility method : wrap your own Promise.
+     * Or use one of the predefined promises.
+     */
+    promisify<T>(): IPromisified<T>;
+    /**
+     * Notify that a process is done and data ready or rejected.
+     * Promise / resolve / reject of current user's language.
+     */
+    onLangReady(): IPromisified<string>;
+    /**
+     * Notify that a process is done and data ready or rejected.
+     * Promise / resolve / reject of current user's session.
+     */
+    onSessionReady(): IPromisified<IUserInfo>;
+    /**
+     * Notify that a process is done and data ready or rejected.
+     * This data is not intended to change after being resolved.
+     * Promise / resolve / reject of asynchronous skin.
+     */
+    onSkinReady(): IPromisified<ITheme>;
+    /**
+     * Notify that a process is done and data ready or rejected.
+     * This data is not intended to change after being resolved.
+     * Promise / resolve / reject of asynchronous skin overrides.
+     */
+    onOverridesReady(): IPromisified<IThemeOverrides>;
+    /**
+     * Notify that the application configuration has been loaded.
+     * This data is not intended to change after being resolved.
+     * Promise / resolve / reject of application configuration.
+     */
+    onAppConfReady(): IPromisified<IGetConf>;
+    /**
+     * Notify that an event occured.
+     * By definition, an event can occur multiple times (otherwise it is a one-time "process", see above) and be watched by many targets.
+     * => We model it as a subject with many potential subscribers.
+     */
+    events(): ISubject;
+}
+export interface IPromisified<T> {
+    readonly promise: Promise<T>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+}
+export declare const LAYER_NAME: {
+    readonly WIDGETS: "widgets";
+    readonly EXPLORER: "explorer";
+    readonly TRANSPORT: "transport";
+    readonly WEB_DATA: "webDataPipeline";
+};
+export type LayerName = (typeof LAYER_NAME)[keyof typeof LAYER_NAME];
+export type TransportLayer = typeof LAYER_NAME.TRANSPORT;
+export type WebDataLayer = typeof LAYER_NAME.WEB_DATA;
+export declare const EVENT_NAME: {
+    readonly USERPREF_CHANGED: "userprefChanged";
+    readonly SEARCH_RESULTED: "searchResulted";
+    readonly ERROR_OCCURED: "error";
+    readonly DATA_TRACKED: "track";
+};
+export type EventName = (typeof EVENT_NAME)[keyof typeof EVENT_NAME];
+/** Generic typing of an event message. */
+export interface ISubjectMessage {
+    name: EventName;
+    data?: any;
+}
+/** A subscription to receive ISubjectMessage */
+export interface ISubscription {
+    /** Close the subscription */
+    revoke: () => void;
+}
+/** Generic typing of a subject. */
+export interface ISubject {
+    subscribe(layer: Omit<LayerName, TransportLayer | WebDataLayer>, handler: <T extends ISubjectMessage>(message: T) => void): ISubscription;
+    publish(layer: Omit<LayerName, TransportLayer | WebDataLayer>, message: ISubjectMessage): void;
+}
+/** Typing of error messages on the TRANSPORT layer. */
+export interface IHttpErrorEvent extends ISubjectMessage {
+    name: typeof EVENT_NAME.ERROR_OCCURED;
+    data: {
+        params?: IHttpParams;
+        response: IHttpResponse;
+        payload?: any;
+    };
+}
+/** Overloaded typing of a subject, dedicated to transport errors. */
+export declare interface ISubject {
+    publish(layer: TransportLayer, message: IHttpErrorEvent): void;
+    subscribe(layer: TransportLayer, handler: (message: IHttpErrorEvent) => void): ISubscription;
+}
+/** Typing of tracked events on a DATA layer. */
+export interface IDataTrackEvent extends ISubjectMessage {
+    name: typeof EVENT_NAME.DATA_TRACKED;
+    data: {
+        'event-type': string;
+        'module'?: string;
+        'userId'?: string;
+        [key: string]: any;
+    };
+}
+/** Overloaded typing of a subject, dedicated to tracking web data events. */
+export declare interface ISubject {
+    publish(layer: WebDataLayer, message: IDataTrackEvent): void;
+    subscribe(layer: WebDataLayer, handler: (message: IDataTrackEvent) => void): ISubscription;
+}

package/dist/resources/ResourceService.d.ts

@@ -0,0 +1,52 @@
+import { App, CreateFolderParameters, CreateFolderResult, DeleteParameters, GetContextParameters, GetContextResult, GetSubFoldersResult, IActionResult, ID, ISearchResults, MoveParameters, PublishParameters, PublishResult, ResourceType, UpdateFolderParameters } from '..';
+import { IOdeServices } from '../services/OdeServices';
+import { CopyParameters, CopyResult, CreateParameters, CreateResult, GetResourceParameters, IResource, IResourceService, IWebResourceService, UpdateParameters, UpdateResult } from './interface';
+export declare abstract class ResourceService implements IResourceService, IWebResourceService {
+    protected context: IOdeServices;
+    private static registry;
+    static register: ({ application, resourceType, }: {
+        application: App | string;
+        resourceType: ResourceType;
+    }, service: (context: IOdeServices) => IResourceService & IWebResourceService) => void;
+    static findService: (lookFor: {
+        application: App | string;
+        resourceType: ResourceType;
+    }, context: IOdeServices) => IResourceService & IWebResourceService;
+    static findMainService: ({ application }: {
+        application: App | string;
+    }, context: IOdeServices) => IResourceService & IWebResourceService;
+    static isRegistered: ({ application, resourceType, }: {
+        application: App | string;
+        resourceType: ResourceType | "main";
+    }) => boolean;
+    constructor(context: IOdeServices);
+    protected get http(): import('../transport/Service').HttpService;
+    abstract getApplication(): App | string;
+    abstract getPrintUrl(resourceId: string): string;
+    abstract getViewUrl(resourceId: string): string;
+    abstract getFormUrl(folderId?: string): string;
+    abstract getEditUrl(resourceId?: string): string;
+    abstract create<T extends CreateParameters>(parameters: T): Promise<CreateResult>;
+    abstract update<T extends UpdateParameters>(parameters: T): Promise<UpdateResult>;
+    abstract getResourceType(): ResourceType;
+    copy(parameters: CopyParameters): Promise<CopyResult>;
+    publish(parameters: PublishParameters): Promise<PublishResult>;
+    createContext(parameters: GetContextParameters): Promise<GetContextResult>;
+    searchContext(parameters: GetContextParameters): Promise<ISearchResults>;
+    searchResource(parameters: GetResourceParameters): Promise<IResource>;
+    createFolder(parameters: CreateFolderParameters): Promise<CreateFolderResult>;
+    updateFolder(parameters: UpdateFolderParameters): Promise<CreateFolderResult>;
+    moveToFolder(parameters: MoveParameters, useAssetId?: boolean): Promise<IActionResult>;
+    listSubfolders(folderId: ID): Promise<GetSubFoldersResult>;
+    deleteAll(parameters: DeleteParameters, useAssetId?: boolean): Promise<IActionResult>;
+    trashAll({ resourceType, ...parameters }: DeleteParameters, useAssetId?: boolean): Promise<IActionResult>;
+    /** Trash folders and/or resources. */
+    restoreAll({ resourceType, ...parameters }: DeleteParameters, useAssetId?: boolean): Promise<IActionResult>;
+    protected checkHttpResponse: <R>(result: R) => R;
+    private mapAssetIdToIds;
+    protected getThumbnailPath(file: string | Blob | File | undefined): Promise<string | undefined>;
+    private toQueryParams;
+    private getResourceParams;
+    private createFolderToBodyParams;
+    private moveToBodyParams;
+}

package/dist/resources/ServiceRegistry.d.ts

@@ -0,0 +1,25 @@
+import { ResourceType, App } from '..';
+import { IOdeServices } from '../services/OdeServices';
+export declare class ServiceRegistry<T> extends Map<string, (context: IOdeServices) => T> {
+    /** Register a service */
+    register({ application, resourceType, }: {
+        application: App | string;
+        resourceType: ResourceType;
+    }, service: (context: IOdeServices) => T): void;
+    /** Lookup for a service */
+    findService(lookFor: {
+        application: App | string;
+        resourceType: ResourceType;
+    }, context: IOdeServices): T;
+    /** Lookup for a main service */
+    findMainService({ application }: {
+        application: App | string;
+    }, context: IOdeServices): T;
+    /** Check if a service is registered. */
+    isRegistered({ application, resourceType, }: {
+        application: App | string;
+        resourceType: ResourceType | 'main';
+    }): boolean;
+    /** Private lookup for a service */
+    private lookupService;
+}

package/dist/resources/SnipletsService.d.ts

@@ -0,0 +1,18 @@
+import { App, ResourceType } from '../globals';
+import { IOdeServices } from '../services/OdeServices';
+import { IBehaviourService } from './interface';
+export declare class SnipletsService {
+    private static registry;
+    static findBehaviour: (lookFor: {
+        application: App | string;
+        resourceType: ResourceType;
+    }, context: IOdeServices) => IBehaviourService;
+    static hasBehaviour: ({ application, resourceType, }: {
+        application: App | string;
+        resourceType: ResourceType | "main";
+    }) => boolean;
+    static resourceProducingApps: App[];
+    static initialize(context: IOdeServices, currentApp: App): Promise<App[]>;
+    static registerBehaviours(currentApp: App): Promise<void>;
+    private static serviceFor;
+}

package/dist/resources/behaviours/AbstractBehaviourService.d.ts

@@ -0,0 +1,34 @@
+import { ID, IHttpParams, ResourceType } from '../..';
+import { IOdeServices } from '../../services/OdeServices';
+import { GetContextParameters, IBehaviourService, IResource } from '../interface';
+export interface LinkerModel {
+    _id: ID;
+    title: string;
+    ownerName: string;
+    owner: string;
+    icon: string;
+    shared: boolean;
+    path?: string;
+    modified: string | {
+        $date: number | string;
+    };
+}
+export interface ILinkedResource extends IResource {
+    path: string;
+}
+/**
+ * TO BE DEPRECATED. DO NOT USE UNLESS YOU KNOW WHAT YOU ARE DOING.
+ */
+export declare abstract class AbstractBehaviourService implements IBehaviourService {
+    protected context: IOdeServices;
+    abstract APP: string;
+    abstract RESOURCE: ResourceType;
+    /** Adapter function to be implemented by subclasses. */
+    abstract loadResources(parameters?: GetContextParameters): Promise<ILinkedResource[]>;
+    constructor(context: IOdeServices);
+    getApplication(): string;
+    getResourceType(): ResourceType;
+    private _cache;
+    protected httpGet<R>(url: string, params?: IHttpParams | undefined): Promise<R>;
+    protected dataToResource({ modified, ...resource }: LinkerModel): ILinkedResource;
+}

package/dist/resources/behaviours/ActualitesBehaviour.d.ts

@@ -0,0 +1,6 @@
+import { AbstractBehaviourService } from './AbstractBehaviourService';
+export declare class ActualitesBehaviour extends AbstractBehaviourService {
+    APP: string;
+    RESOURCE: string;
+    loadResources(): Promise<import('./AbstractBehaviourService').ILinkedResource[]>;
+}

package/dist/resources/behaviours/BlogBehaviour.d.ts

@@ -0,0 +1,6 @@
+import { AbstractBehaviourService, ILinkedResource } from './AbstractBehaviourService';
+export declare class BlogBehaviour extends AbstractBehaviourService {
+    APP: string;
+    RESOURCE: string;
+    loadResources(): Promise<ILinkedResource[]>;
+}

package/dist/resources/behaviours/CollaborativewallBehaviour.d.ts

@@ -0,0 +1,6 @@
+import { AbstractBehaviourService } from './AbstractBehaviourService';
+export declare class CollaborativewallBehaviour extends AbstractBehaviourService {
+    APP: string;
+    RESOURCE: string;
+    loadResources(): Promise<import('./AbstractBehaviourService').ILinkedResource[]>;
+}

package/dist/resources/behaviours/CommunityBehaviour.d.ts

@@ -0,0 +1,6 @@
+import { AbstractBehaviourService } from './AbstractBehaviourService';
+export declare class CommunityBehaviour extends AbstractBehaviourService {
+    APP: string;
+    RESOURCE: string;
+    loadResources(): Promise<import('./AbstractBehaviourService').ILinkedResource[]>;
+}

package/dist/resources/behaviours/ExercizerBehaviour.d.ts

@@ -0,0 +1,6 @@
+import { AbstractBehaviourService } from './AbstractBehaviourService';
+export declare class ExercizerBehaviour extends AbstractBehaviourService {
+    APP: string;
+    RESOURCE: string;
+    loadResources(): Promise<import('./AbstractBehaviourService').ILinkedResource[]>;
+}

package/dist/resources/behaviours/FormulaireBehaviour.d.ts

@@ -0,0 +1,6 @@
+import { AbstractBehaviourService } from './AbstractBehaviourService';
+export declare class FormulaireBehaviour extends AbstractBehaviourService {
+    APP: string;
+    RESOURCE: string;
+    loadResources(): Promise<import('./AbstractBehaviourService').ILinkedResource[]>;
+}

package/dist/resources/behaviours/ForumBehaviour.d.ts

@@ -0,0 +1,6 @@
+import { AbstractBehaviourService } from './AbstractBehaviourService';
+export declare class ForumBehaviour extends AbstractBehaviourService {
+    APP: string;
+    RESOURCE: string;
+    loadResources(): Promise<import('./AbstractBehaviourService').ILinkedResource[]>;
+}

package/dist/resources/behaviours/HomeworksBehaviour.d.ts

@@ -0,0 +1,6 @@
+import { AbstractBehaviourService } from './AbstractBehaviourService';
+export declare class HomeworksBehaviour extends AbstractBehaviourService {
+    APP: string;
+    RESOURCE: string;
+    loadResources(): Promise<import('./AbstractBehaviourService').ILinkedResource[]>;
+}

package/dist/resources/behaviours/MagnetoBehaviour.d.ts

@@ -0,0 +1,6 @@
+import { AbstractBehaviourService } from './AbstractBehaviourService';
+export declare class MagnetoBehaviour extends AbstractBehaviourService {
+    APP: string;
+    RESOURCE: string;
+    loadResources(): Promise<import('./AbstractBehaviourService').ILinkedResource[]>;
+}

package/dist/resources/behaviours/MindmapBehaviour.d.ts

@@ -0,0 +1,6 @@
+import { AbstractBehaviourService } from './AbstractBehaviourService';
+export declare class MindmapBehaviour extends AbstractBehaviourService {
+    APP: string;
+    RESOURCE: string;
+    loadResources(): Promise<import('./AbstractBehaviourService').ILinkedResource[]>;
+}

package/dist/resources/behaviours/PagesBehaviour.d.ts

@@ -0,0 +1,6 @@
+import { AbstractBehaviourService, ILinkedResource } from './AbstractBehaviourService';
+export declare class PagesBehaviour extends AbstractBehaviourService {
+    APP: string;
+    RESOURCE: string;
+    loadResources(): Promise<ILinkedResource[]>;
+}

package/dist/resources/behaviours/PollBehaviour.d.ts

@@ -0,0 +1,6 @@
+import { AbstractBehaviourService } from './AbstractBehaviourService';
+export declare class PollBehaviour extends AbstractBehaviourService {
+    APP: string;
+    RESOURCE: string;
+    loadResources(): Promise<import('./AbstractBehaviourService').ILinkedResource[]>;
+}

package/dist/resources/behaviours/ScrapbookBehaviour.d.ts

@@ -0,0 +1,6 @@
+import { AbstractBehaviourService } from './AbstractBehaviourService';
+export declare class ScrapbookBehaviour extends AbstractBehaviourService {
+    APP: string;
+    RESOURCE: string;
+    loadResources(): Promise<import('./AbstractBehaviourService').ILinkedResource[]>;
+}

package/dist/resources/behaviours/TimelinegeneratorBehaviour.d.ts

@@ -0,0 +1,6 @@
+import { AbstractBehaviourService, ILinkedResource } from './AbstractBehaviourService';
+export declare class TimelinegeneratorBehaviour extends AbstractBehaviourService {
+    APP: string;
+    RESOURCE: string;
+    loadResources(): Promise<ILinkedResource[]>;
+}

package/dist/resources/behaviours/WikiBehaviour.d.ts

@@ -0,0 +1,6 @@
+import { AbstractBehaviourService } from './AbstractBehaviourService';
+export declare class WikiBehaviour extends AbstractBehaviourService {
+    APP: string;
+    RESOURCE: string;
+    loadResources(): Promise<import('./AbstractBehaviourService').ILinkedResource[]>;
+}

package/dist/resources/behaviours/WorkspaceBehaviour.d.ts

@@ -0,0 +1,7 @@
+import { GetContextParameters } from '../interface';
+import { AbstractBehaviourService, ILinkedResource } from './AbstractBehaviourService';
+export declare class WorkspaceBehaviour extends AbstractBehaviourService {
+    APP: string;
+    RESOURCE: string;
+    loadResources({ search, asset_id }: GetContextParameters): Promise<ILinkedResource[]>;
+}