@limetech/lime-web-components 4.48.2 → 4.49.1-alpha.4

package/dist/navigator/navigator.d.ts

@@ -0,0 +1,158 @@
+/**
+ * The {@link Navigator} service lets you navigate to a new location within the
+ * application, or update the current location with new data. A location is
+ * defined by a path and optional data.
+ *
+ * When navigating to a new location, a new entry will be pushed to the history
+ * stack in the browser and the {@link EventDispatcher} will emit a
+ * {@link NavigationEvent}.
+ *
+ * New locations can be registered using the {@link RouteRegistry} service
+ *
+ * @example
+ * // Listen on navigation events
+ * eventDispatcher.addListener('navigate', onNavigate);
+ * navigator.navigate('/object/deal/1001');
+ *
+ * function onNavigate(event: NavigationEvent) {
+ *     console.log(event.detail);
+ * }
+ *
+ * @experimental
+ */
+export interface Navigator {
+    /**
+     * Navigate to a new location
+     *
+     * @emits navigate - When the location has been changed the
+     * {@link EventDispatcher} will emit a {@link NavigationEvent}
+     *
+     * @param {string} path path to the location
+     * @param query query string parameters to append to the URL
+     */
+    navigate(path: string, query?: Location['query']): void;
+    /**
+     * Navigate to a new location or update the current location with new data
+     *
+     * By default, it is automatically decided whether to replace the current
+     * history entry or push a new one. If no new path is provided, or if it
+     * resolves to an unchanged path of the URL (not including the query string
+     * or fragment), the current history entry will be updated with the
+     * provided location data.
+     *
+     * You can also set `location.method` to push or replace instead.
+     * When pushing a new entry, `location.state` defaults to `null`.
+     * When replacing, state will only be changed if a new value is provided.
+     *
+     * @emits navigate - When the location has been changed the
+     * {@link EventDispatcherService} will emit a {@link NavigationEvent}
+     *
+     * @param location a new location or parts of the location to replace
+     */
+    navigate(location: LocationChange): void;
+    /**
+     * Get the current location
+     *
+     * @return {Location}
+     */
+    getLocation(): Location;
+    /**
+     * Add a blocker that can prevent navigation away from the current page, for
+     * example when there is some unsaved data that would otherwise be discarded.
+     *
+     * If the blocker function returns true navigation is blocked. If it returns
+     * false navigation will proceed as normal, if not blocked by other blockers.
+     *
+     * To later on resume navigation that was blocked, you can call the supplied
+     * {@link Transition.retry} method.
+     *
+     * @note Blockers are not guaranteed to be executed upon a navigation event.
+     * Blockers will be executed until either all returns false or up until one
+     * of them returns true.
+     *
+     * @example
+     * navigator.addBlocker(myBlocker);
+     *
+     * function myBlocker(transition) {
+     *   showConfirmDialog().then((shouldNavigate) => {
+     *     if (shouldNavigate) {
+     *       navigator.removeBlocker(myBlocker);
+     *       transition.retry()
+     *     }
+     *   });
+     *   return true;
+     * }
+     *
+     * @param {Blocker} blocker function to be called before navigation
+     */
+    addBlocker(blocker: Blocker): void;
+    /**
+     * Removes a previously configured blocker.
+     *
+     * @param {Blocker} blocker previously added blocker function
+     */
+    removeBlocker(blocker: Blocker): void;
+    /**
+     * Create a URL for the given location
+     *
+     * @param {Partial<Location>} location the location to create a URL for.
+     * Any `state` of the location will be ignored.
+     *
+     * @return {URL} the URL to the location
+     */
+    createUrl(location: Partial<Location>): URL;
+}
+export declare type Location = {
+    /**
+     * The path to the location
+     */
+    path: string;
+    /**
+     * The parsed query string parameters. The values are parsed using `JSON.parse()`.
+     */
+    query: Record<string, unknown>;
+    /**
+     * The URL fragment identifier, beginning with a #.
+     */
+    hash: string;
+    /**
+     * The history state.
+     */
+    state: unknown;
+};
+export declare type LocationChange = Partial<Location> & {
+    /**
+     * Specifies whether to push a new entry or replace the current entry in
+     * the history stack
+     */
+    method?: 'push' | 'replace';
+};
+/**
+ * @event navigate - Emitted when a new location is navigated to or the current
+ * location is updated
+ */
+export declare type NavigationEvent = CustomEvent<Location>;
+/**
+ * Function to retry navigation
+ */
+export declare type Retry = () => void;
+/**
+ * {@link Transition} describes the transition when navigating from a
+ * {@link Location} to another {@link Location}.
+ *
+ * @param {Location} to location to navigate to
+ * @param {Location} from current location before navigation
+ * @param {Retry} retry function to retry navigation
+ */
+export declare type Transition = {
+    to: Location;
+    from: Location;
+    retry: Retry;
+};
+/**
+ * Function to determine if navigation should be blocked or not.
+ *
+ * @param {Transition} transition the transition to evaluate
+ * @returns true if navigation should be blocked
+ */
+export declare type Blocker = (transition: Transition) => boolean;

package/dist/navigator/navigator.js

@@ -0,0 +1 @@
+export {};

package/dist/navigator/types.d.ts

@@ -0,0 +1,17 @@
+import { Navigator as Service } from './navigator';
+declare const SERVICE_NAME = "navigator";
+declare module '../core/platform' {
+    interface PlatformServiceName {
+        /**
+         * @see {@link Service Navigator}
+         *
+         * @note Work in progress, do not use!
+         * @private
+         */
+        Navigator: typeof SERVICE_NAME;
+    }
+    interface LimeWebComponentPlatform {
+        get(name: PlatformServiceName['Navigator']): Service;
+    }
+}
+export {};

package/dist/navigator/types.js

@@ -0,0 +1,3 @@
+import { PlatformServiceName } from '../core/platform';
+const SERVICE_NAME = 'navigator';
+PlatformServiceName.Navigator = SERVICE_NAME;

package/dist/notifications/index.d.ts

@@ -0,0 +1,2 @@
+export * from './notifications';
+export * from './types';

package/dist/notifications/index.js

@@ -0,0 +1,2 @@
+export * from './notifications';
+export * from './types';

package/dist/notifications/notifications.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Service for displaying different notification messages
+ */
+export interface Notifications {
+    /**
+     * Display a blocking alert dialog
+     *
+     * @param {string} title title of the dialog
+     * @param {string} message message to display in the dialog
+     * @param {AlertOptions} options
+     * @returns {Promise<void>} a promise that will be resolved when the dialog is closed
+     */
+    alert(title: string, message: string, options?: AlertOptions): Promise<void>;
+    /**
+     * Display a blocking confirm dialog
+     *
+     * @param {string} title title of the dialog
+     * @param {string} message message to display in the dialog
+     * @param {ConfirmOptions} options
+     * @returns {Promise<boolean>} a promise that will be resolved to true when the dialog is closed.
+     * If the accepting button was pressed, the promise will resolve to true.
+     * Otherwise, the promise will resolve to false.
+     */
+    confirm(title: string, message: string, options?: ConfirmOptions): Promise<boolean>;
+    /**
+     * Display a non-blocking notification
+     *
+     * @param {string} message message to display in the notification
+     * @param {NotificationOptions} options
+     * @returns {Promise<boolean>} a promise that will be resolved when the notification is closed.
+     * If the notification has an action button and it was pressed, the promise will resolve to true.
+     * Otherwise, the promise will resolve to false.
+     */
+    notify(message: string, options?: NotificationOptions): Promise<boolean>;
+    /**
+     * Display a non-blocking and non-transient message
+     *
+     * @param {string} message message to display in the banner
+     * @param {ReportOptions} options
+     * @returns {Promise<boolean>} a promise that will be resolved when the notification is closed.
+     * If the notification has an action button and it was pressed, the promise will resolve to true.
+     * Otherwise, the promise will resolve to false.
+     */
+    report(message: string, options?: ReportOptions): Promise<boolean>;
+}
+/**
+ * Options for the confirmation dialog
+ */
+export interface AlertOptions {
+    /**
+     * Text to display on the button
+     */
+    acceptText?: string;
+}
+/**
+ * Options for the confirmation dialog
+ */
+export interface ConfirmOptions {
+    /**
+     * Text to display on the button for the accept action
+     */
+    acceptText?: string;
+    /**
+     * Text to display on the button for the cancel action
+     */
+    cancelText?: string;
+}
+/**
+ * Options for notifications
+ */
+export interface NotificationOptions {
+    /**
+     * Number of milliseconds to wait before the notification auto fades.
+     */
+    timeout?: number;
+    /**
+     * Text to display on the action button
+     */
+    actionText?: string;
+    /**
+     * Set to true to display the message on multiple lines
+     */
+    multiline?: boolean;
+    /**
+     * Set to true to make the notification dismissible
+     */
+    dismissible?: boolean;
+}
+/**
+ * Options for reports
+ */
+export interface ReportOptions {
+    /**
+     * Text to display on the action button
+     */
+    actionText?: string;
+    /**
+     * Icon to display on the banner
+     */
+    icon?: string;
+}

package/dist/notifications/notifications.js

@@ -0,0 +1 @@
+export {};

package/dist/notifications/types.d.ts

@@ -0,0 +1,14 @@
+import { Notifications } from './notifications';
+declare const SERVICE_NAME = "notifications";
+declare module '../core/platform' {
+    interface PlatformServiceName {
+        /**
+         * @see {@link Notifications}
+         */
+        Notification: typeof SERVICE_NAME;
+    }
+    interface LimeWebComponentPlatform {
+        get(name: PlatformServiceName['Notification']): Notifications;
+    }
+}
+export {};

package/dist/notifications/types.js

@@ -0,0 +1,3 @@
+import { PlatformServiceName } from '../core/platform';
+const SERVICE_NAME = 'notifications';
+PlatformServiceName.Notification = SERVICE_NAME;

package/dist/query/index.d.ts

@@ -0,0 +1,3 @@
+export * from './query';
+export * from './service';
+export * from './types';

package/dist/query/index.js

@@ -0,0 +1,3 @@
+export * from './query';
+export * from './service';
+export * from './types';

package/dist/query/query.d.ts

@@ -0,0 +1,46 @@
+export interface Query {
+    limetype: string;
+    limit?: number;
+    offset?: number;
+    orderBy?: object[];
+    filter?: Expression;
+    responseFormat: {
+        object?: object;
+        aggregates?: object;
+    };
+}
+export interface QueryResponse {
+    objects: any[];
+    aggregates: any;
+}
+export interface Expression {
+    key?: string;
+    op: Operator;
+    exp: any;
+    type?: 'filter';
+}
+export declare enum Operator {
+    AND = "AND",
+    OR = "OR",
+    EQUALS = "=",
+    NOT = "!",
+    GREATER = ">",
+    LESS = "<",
+    IN = "IN",
+    BEGINS = "=?",
+    LIKE = "?",
+    LESS_OR_EQUAL = "<=",
+    GREATER_OR_EQUAL = ">="
+}
+export interface Filter {
+    id: string;
+    limetype: string;
+    name: {
+        [language: string]: string;
+    };
+    filter: Expression;
+    description?: {
+        [language: string]: string;
+    };
+    iduser?: number;
+}

package/dist/query/query.js

@@ -0,0 +1,14 @@
+export var Operator;
+(function (Operator) {
+    Operator["AND"] = "AND";
+    Operator["OR"] = "OR";
+    Operator["EQUALS"] = "=";
+    Operator["NOT"] = "!";
+    Operator["GREATER"] = ">";
+    Operator["LESS"] = "<";
+    Operator["IN"] = "IN";
+    Operator["BEGINS"] = "=?";
+    Operator["LIKE"] = "?";
+    Operator["LESS_OR_EQUAL"] = "<=";
+    Operator["GREATER_OR_EQUAL"] = ">=";
+})(Operator || (Operator = {}));

package/dist/query/service.d.ts

@@ -0,0 +1,12 @@
+import { Query, QueryResponse } from '../query';
+/**
+ * Service for executing queries using the query objects API
+ */
+export interface QueryService {
+    /**
+     * Execute a query
+     *
+     * @param query
+     */
+    execute(query: Query): Promise<QueryResponse>;
+}

package/dist/query/service.js

@@ -0,0 +1 @@
+export {};

package/dist/query/types.d.ts

@@ -0,0 +1,14 @@
+import { QueryService } from './service';
+declare const SERVICE_NAME = "query";
+declare module '../core/platform' {
+    interface PlatformServiceName {
+        /**
+         * @see {@link QueryService}
+         */
+        Query: typeof SERVICE_NAME;
+    }
+    interface LimeWebComponentPlatform {
+        get(name: PlatformServiceName['Query']): QueryService;
+    }
+}
+export {};

package/dist/query/types.js

@@ -0,0 +1,3 @@
+import { PlatformServiceName } from '../core/platform';
+const SERVICE_NAME = 'query';
+PlatformServiceName.Query = SERVICE_NAME;

package/dist/routeregistry/index.d.ts

@@ -0,0 +1,2 @@
+export * from './registry';
+export * from './types';

package/dist/routeregistry/index.js

@@ -0,0 +1,2 @@
+export * from './registry';
+export * from './types';

package/dist/routeregistry/registry.d.ts

@@ -0,0 +1,92 @@
+import { LimeWebComponent } from '../core';
+/**
+ * The {@link RouteRegistry} service lets you register new locations in the
+ * application specified by either a path or a path pattern. Once a location
+ * has been registered, it can be navigated to using the {@link Navigator}
+ * service.
+ *
+ * When registering a route, any parameters in the path will be used as props
+ * on the component when it is being rendered. Parameters will be of type
+ * `string`, when the parameter can be parsed as a number the type will instead
+ * be `number`. Components that are registered in the {@link RouteRegistry}
+ * should implement {@link RouteComponent}.
+ *
+ * @note Since components are assumed to implement {@link RouteComponent} some
+ * parameters can not be used as path parameters and some will have special
+ * meaning. Special handling will be used for parameters named `limetype` and
+ * `id` to create a {@link LimeWebComponentContext} for the component. `id` can
+ * be used on it's own, but will be used to create `context` if `limetype` is
+ * also present. The following should not be used since they are part of
+ * {@link RouteComponent}:
+ * - `platform`
+ * - `context`
+ * - `query`
+ * - `hash`
+ * - `state`
+ *
+ * @example
+ * // Registering a simple route
+ * routeRegistry.registerRoute('/foo', 'foo-component');
+ *
+ * @example
+ * // Registering a route with parameters
+ * // `name` will be used as a prop on the component when it renders
+ * routeRegistry.registerRoute('/foo/:name', 'foo-component');
+ *
+ * @example
+ * // Registering a route with a context
+ * // The `context` prop of the component will have the values of the
+ * // `limetype` and `id` parameters
+ * routeRegistry.registerRoute('/foo/:limetype/:id', 'foo-component');
+ *
+ * @experimental
+ */
+export interface RouteRegistry {
+    /**
+     * Register a route for a component.
+     *
+     * @param {string} pathPattern - path pattern used to match a component.
+     * For more information about URL patterns read [MDN Web Docs](https://developer.mozilla.org/en-US/docs/Web/API/URL_Pattern_API).
+     * @param {string} component - Name of the component to register for the
+     * specified pattern
+     */
+    registerRoute(pathPattern: string, component: string): void;
+    /**
+     * Find the component for a given path.
+     *
+     * @param {string} path - The path to match against.
+     * @return {MatchedComponent | undefined} the matched component along with
+     * path parameters, or `undefined` if no component could be found.
+     */
+    findComponent(path: string): MatchedComponent | undefined;
+}
+export declare type MatchedComponent = {
+    /**
+     * The name of the component.
+     */
+    name: string;
+    /**
+     * Matched path parameters.
+     */
+    props: Record<string, string | number>;
+};
+/**
+ * Interface for components that are routed to and are registered with the
+ * {@link RouteRegistry} service.
+ *
+ * @experimental
+ */
+export interface RouteComponent extends LimeWebComponent {
+    /**
+     * Query parameters from the route URL
+     */
+    query?: Record<string, unknown>;
+    /**
+     * The URL fragment identifier
+     */
+    hash?: string;
+    /**
+     * The history state
+     */
+    state?: unknown;
+}

package/dist/routeregistry/registry.js

@@ -0,0 +1 @@
+export {};

package/dist/routeregistry/types.d.ts

@@ -0,0 +1,17 @@
+import { RouteRegistry as Service } from './registry';
+declare const SERVICE_NAME = "routeRegistry";
+declare module '../core/platform' {
+    interface PlatformServiceName {
+        /**
+         * @see {@link Service RouteRegistry}
+         *
+         * @note Work in progress, do not use!
+         * @private
+         */
+        RouteRegistry: typeof SERVICE_NAME;
+    }
+    interface LimeWebComponentPlatform {
+        get(name: PlatformServiceName['RouteRegistry']): Service;
+    }
+}
+export {};

package/dist/routeregistry/types.js

@@ -0,0 +1,3 @@
+import { PlatformServiceName } from '../core/platform';
+const SERVICE_NAME = 'routeRegistry';
+PlatformServiceName.RouteRegistry = SERVICE_NAME;

package/dist/task/index.d.ts

@@ -0,0 +1,2 @@
+export * from './repository';
+export * from './types';

package/dist/task/index.js

@@ -0,0 +1,2 @@
+export * from './repository';
+export * from './types';

package/dist/task/repository.d.ts

@@ -0,0 +1,82 @@
+import { StateRepository } from '../core';
+/**
+ * Service for creating background tasks
+ */
+export interface TaskRepository extends StateRepository {
+    /**
+     * Create a new background task
+     *
+     * @param url url to the resource that will create the task
+     * @param data task specific data
+     * @param cancelAction true to allow task creation to be cancelled
+     * @param message notification message to display before the task is created instead of the default one
+     * @returns a promise that resolves to the id of the task if it was created successfully
+     */
+    create(url: string, data: any, cancelAction?: boolean, message?: string): Promise<string | void>;
+    /**
+     * Get status about specific tasks
+     *
+     * @param ids the ids of the tasks to check
+     * @returns a promise that resolves to the status about the tasks
+     */
+    getStatus(ids: string[]): Promise<TaskStatus[]>;
+}
+export declare enum TaskState {
+    /**
+     * Task state is unknown
+     */
+    Pending = "PENDING",
+    /**
+     * Task was started by a worker
+     */
+    Started = "STARTED",
+    /**
+     * Task is waiting for retry
+     */
+    Retry = "RETRY",
+    /**
+     * Task succeeded
+     */
+    Success = "SUCCESS",
+    /**
+     * Task failed
+     */
+    Failure = "FAILURE"
+}
+export interface TaskStatus {
+    /**
+     * ID of the task
+     */
+    id: string;
+    /**
+     * The state of the task
+     */
+    status: TaskState;
+    /**
+     * The result of the task once it has finished its execution
+     */
+    result?: string;
+}
+/**
+ * Events dispatched by the task service
+ */
+export declare enum TaskEventType {
+    /**
+     * Dispatched when a task has been created.
+     *
+     * @detail { task }
+     */
+    Created = "task.created",
+    /**
+     * Dispatched when the task has successfully been completed
+     *
+     * @detail { task }
+     */
+    Success = "task.success",
+    /**
+     * Dispatched if an error occured while running the task
+     *
+     * @detail { task | error? }
+     */
+    Failed = "task.failed"
+}