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

package/dist/limeobject/commands/object-access.d.ts

@@ -0,0 +1,10 @@
+import { LimeType } from '../../limetype';
+/**
+ * Open a dialog to view and edit object access information
+ *
+ * @id `limeobject.object-access`
+ */
+export declare class OpenObjectAccessDialogCommand {
+    id: number;
+    limetype: LimeType;
+}

package/dist/limeobject/commands/object-access.js

@@ -0,0 +1,15 @@
+import { __decorate } from "tslib";
+import { Command } from '../../commandbus';
+/**
+ * Open a dialog to view and edit object access information
+ *
+ * @id `limeobject.object-access`
+ */
+let OpenObjectAccessDialogCommand = class OpenObjectAccessDialogCommand {
+};
+OpenObjectAccessDialogCommand = __decorate([
+    Command({
+        id: 'limeobject.object-access',
+    })
+], OpenObjectAccessDialogCommand);
+export { OpenObjectAccessDialogCommand };

package/dist/limeobject/commands/save-object.d.ts

@@ -0,0 +1,16 @@
+import { LimeObject } from '../../limeobject';
+/**
+ * Saves the object to the database
+ *
+ * @id `limeobject.save-object`
+ */
+export declare class SaveLimeObjectCommand {
+    /**
+     * The limeobject to save
+     */
+    limeobject: LimeObject;
+    /**
+     * Specifies if routing to limeobject should be done after confirmation
+     */
+    route?: boolean;
+}

package/dist/limeobject/commands/save-object.js

@@ -0,0 +1,21 @@
+import { __decorate } from "tslib";
+import { Command } from '../../commandbus';
+/**
+ * Saves the object to the database
+ *
+ * @id `limeobject.save-object`
+ */
+let SaveLimeObjectCommand = class SaveLimeObjectCommand {
+    constructor() {
+        /**
+         * Specifies if routing to limeobject should be done after confirmation
+         */
+        this.route = false;
+    }
+};
+SaveLimeObjectCommand = __decorate([
+    Command({
+        id: 'limeobject.save-object',
+    })
+], SaveLimeObjectCommand);
+export { SaveLimeObjectCommand };

package/dist/limeobject/decorator.d.ts

@@ -0,0 +1,32 @@
+import { StateOptions, LimeWebComponent, ContextAwareStateOptions } from '../core';
+/**
+ * Config for the {@link SelectLimeObjects} state decorator
+ */
+export interface SelectLimeObjectsOptions extends StateOptions {
+    /**
+     * LimeType of the object
+     */
+    limetype?: string;
+    /**
+     * A function to get the limetype
+     */
+    getLimetype?: (component: LimeWebComponent) => string;
+    /**
+     * Id of the limeobject
+     */
+    id?: number;
+}
+/**
+ * Get a list of limeobjects
+ *
+ * @param {SelectLimeObjectsOptions} [options] state decorator options
+ * @returns {Function} state decorator
+ */
+export declare function SelectLimeObjects(options?: SelectLimeObjectsOptions): PropertyDecorator;
+/**
+ * Get the limeobject for the current context
+ *
+ * @param {StateOptions} [options] state decorator options
+ * @returns {Function} state decorator
+ */
+export declare function SelectCurrentLimeObject(options?: ContextAwareStateOptions): PropertyDecorator;

package/dist/limeobject/decorator.js

@@ -0,0 +1,42 @@
+import { PlatformServiceName, } from '../core';
+import { createStateDecorator } from '../core/decorators/factory';
+/**
+ * Get a list of limeobjects
+ *
+ * @param {SelectLimeObjectsOptions} [options] state decorator options
+ * @returns {Function} state decorator
+ */
+export function SelectLimeObjects(options = {}) {
+    const config = {
+        name: PlatformServiceName.LimeObjectRepository,
+        optionFactory: createOptions,
+    };
+    return createStateDecorator(options, config);
+}
+/**
+ * Get the limeobject for the current context
+ *
+ * @param {StateOptions} [options] state decorator options
+ * @returns {Function} state decorator
+ */
+export function SelectCurrentLimeObject(options = {}) {
+    const config = {
+        name: PlatformServiceName.LimeObjectRepository,
+    };
+    options.map = [currentLimeobject, ...(options.map || [])];
+    options.context = null;
+    return createStateDecorator(options, config);
+}
+function currentLimeobject(limeobjects) {
+    const { limetype, id } = this.context;
+    if (!limeobjects[limetype]) {
+        return undefined;
+    }
+    return limeobjects[limetype].find((object) => object.id === id);
+}
+function createOptions(options, component) {
+    if (options.getLimetype) {
+        options.limetype = options.getLimetype(component);
+    }
+    return options;
+}

package/dist/limeobject/error.d.ts

@@ -0,0 +1,4 @@
+import { LimeObject } from './limeobject';
+export interface SaveLimeObjectError extends Error {
+    limeobject: LimeObject;
+}

package/dist/limeobject/error.js

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

package/dist/limeobject/index.d.ts

@@ -0,0 +1,6 @@
+export * from './limeobject';
+export * from './error';
+export * from './repository';
+export * from './types';
+export * from './decorator';
+export * from './commands';

package/dist/limeobject/index.js

@@ -0,0 +1,6 @@
+export * from './limeobject';
+export * from './error';
+export * from './repository';
+export * from './types';
+export * from './decorator';
+export * from './commands';

package/dist/limeobject/limeobject.d.ts

@@ -0,0 +1,43 @@
+import { LimeType } from '../limetype';
+/**
+ * A Lime object
+ */
+export interface LimeObject {
+    /**
+     * Id of the lime object
+     */
+    id: number;
+    /**
+     * The created time of the limeobject
+     */
+    createdtime: string;
+    /**
+     * The last time the limeobject updated
+     */
+    timestamp: string;
+    /**
+     * Descriptive of the limeobject
+     */
+    descriptive: string;
+    /**
+     * Get the value of a property by name
+     *
+     * @param {string} name name of property to get the value of. Allows a path
+     * to be specified using dot notation to get the value of a related
+     * property
+     *
+     * @returns {any} the value of the specified property. If it is a relation,
+     * the related `LimeObject` will be returned
+     */
+    getValue(name: string): any;
+    /**
+     * Get the limetype of the object
+     *
+     * @returns {Limetype} the limetype
+     */
+    getLimetype(): LimeType;
+    /**
+     * Dynamic properties of the limeobject
+     */
+    [property: string]: any;
+}

package/dist/limeobject/limeobject.js

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

package/dist/limeobject/repository.d.ts

@@ -0,0 +1,113 @@
+import { Expression } from '../query';
+import { StateRepository } from '../core';
+export interface LimeObjectRepository extends StateRepository {
+    /**
+     * Load the specified limeobject into the state
+     *
+     * @param {string} limetype
+     * @param {number} id
+     */
+    loadObject(limetype: string, id: number): void;
+    /**
+     * Load objects of the specified limetype into the state
+     *
+     * @param {string} limetype name of the limetype
+     * @param {LoadOptions} options options about the objects to load
+     * @returns {ObjectResponse} list of objects together with total count of objects
+     */
+    loadObjects?(limetype: string, options?: LoadOptions): Promise<ObjectResponse>;
+    /**
+     * Load related objects into the state
+     *
+     * @param {string} limetype name of the limetype of the owning limeobject
+     * @param {number} id the id of the owning limeobject
+     * @param {string} property name of the property that contain the relations
+     * @param {LoadOptions} options options about the objects to load
+     * @returns {ObjectResponse} list of related objects together with total count of objects
+     */
+    loadRelations(limetype: string, id: number, property: string, options?: LoadOptions): Promise<ObjectResponse>;
+    /**
+     * Loads a schema for the limetype.
+     *
+     * @param {string} limetype name of the limetype of the owning limeobject
+     */
+    loadSchema?(limetype: string): Promise<object>;
+    /**
+     * Reload the specified limeobject and update corresponding views in the webclient
+     *
+     * NOTE: This is just a temporary method that can be used to get around some quirks in the current version of the
+     * webclient. It is deprecated and code should not rely on its existance. Check if the method exists before using
+     * it to make code backwards compatible, e.g. `limeobjects.reload && limeobjects.reload('company', 1001)`
+     *
+     * Once the quirks in the webclient have been fixed, there should be no need for this method and objects should
+     * update themselves automatically.
+     *
+     * @deprecated
+     */
+    reloadObject?(limetype: string, id: number): void;
+    /**
+     * Delete the specified limeobject
+     *
+     * @param {string} limetype name of the limetype of the limeobject
+     * @param {number} id the id of the limeobject
+     */
+    deleteObject?(limetype: string, id: number): Promise<void>;
+}
+export interface LoadOptions {
+    /**
+     * Maximum number of objects to load
+     */
+    limit?: number;
+    /**
+     * Offset of the objects to load
+     */
+    offset?: number;
+    /**
+     * Filter to apply to the objects
+     */
+    filter?: Expression;
+    /**
+     * Order to sort the properties by
+     */
+    order?: PropertyOrder[];
+}
+export interface PropertyOrder {
+    /**
+     * Name of the property to sort on
+     */
+    name: string;
+    /**
+     * The direction to order the property by
+     */
+    direction: 'ASC' | 'DESC';
+}
+export interface ObjectResponse {
+    /**
+     * The objects that matched the query
+     */
+    objects: object[];
+    /**
+     * Total number of objects that exist matching the query
+     */
+    totalCount: number;
+    /**
+     * Total number of objects that exist (without any filter applied)
+     */
+    totalRelations?: number;
+    /**
+     * Aggregated data
+     */
+    aggregates?: AggregationGroups;
+}
+export interface AggregationGroups {
+    /**
+     * Name of the aggregation group along with a list of aggregations
+     */
+    [name: string]: ObjectAggregation[];
+}
+export interface ObjectAggregation {
+    /**
+     * Name of the property being aggregated along with its aggregated value
+     */
+    [property: string]: number | string;
+}

package/dist/limeobject/repository.js

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

package/dist/limeobject/types.d.ts

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

package/dist/limeobject/types.js

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

package/dist/limetype/acl.d.ts

@@ -0,0 +1,6 @@
+export interface Acl {
+    delete: boolean;
+    read: boolean;
+    update: boolean;
+    create: boolean;
+}

package/dist/limetype/acl.js

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

package/dist/limetype/decorator.d.ts

@@ -0,0 +1,21 @@
+import { StateOptions, ContextAwareStateOptions } from '../core';
+/**
+ * Config for the {@link SelectLimeTypes} state decorator
+ */
+export interface SelectLimeTypesOptions extends StateOptions {
+    name?: string;
+}
+/**
+ * Gets an object with all limetypes where name is used as key
+ *
+ * @param {SelectLimeTypesOptions} [options] state decorator options
+ * @returns {Function} state decorator
+ */
+export declare function SelectLimeTypes(options?: SelectLimeTypesOptions): PropertyDecorator;
+/**
+ * Get the limetype for the current context
+ *
+ * @param {StateOptions} [options] state decorator options
+ * @returns {Function} state decorator
+ */
+export declare function SelectCurrentLimeType(options?: ContextAwareStateOptions): PropertyDecorator;

package/dist/limetype/decorator.js

@@ -0,0 +1,32 @@
+import { PlatformServiceName, } from '../core';
+import { createStateDecorator } from '../core/decorators/factory';
+/**
+ * Gets an object with all limetypes where name is used as key
+ *
+ * @param {SelectLimeTypesOptions} [options] state decorator options
+ * @returns {Function} state decorator
+ */
+export function SelectLimeTypes(options = {}) {
+    const config = {
+        name: PlatformServiceName.LimeTypeRepository,
+    };
+    return createStateDecorator(options, config);
+}
+/**
+ * Get the limetype for the current context
+ *
+ * @param {StateOptions} [options] state decorator options
+ * @returns {Function} state decorator
+ */
+export function SelectCurrentLimeType(options = {}) {
+    const config = {
+        name: PlatformServiceName.LimeTypeRepository,
+    };
+    options.map = [currentLimetype, ...(options.map || [])];
+    options.context = null;
+    return createStateDecorator(options, config);
+}
+function currentLimetype(limetypes) {
+    const { limetype } = this.context;
+    return limetypes[limetype];
+}

package/dist/limetype/index.d.ts

@@ -0,0 +1,5 @@
+export * from './acl';
+export * from './limetype';
+export * from './property';
+export * from './types';
+export * from './decorator';

package/dist/limetype/index.js

@@ -0,0 +1,5 @@
+export * from './acl';
+export * from './limetype';
+export * from './property';
+export * from './types';
+export * from './decorator';

package/dist/limetype/limetype.d.ts

@@ -0,0 +1,25 @@
+import { Acl } from './acl';
+import { LimeProperty } from './property';
+export interface LimeType {
+    name: string;
+    label: string;
+    acl: Acl;
+    localname: {
+        singular: string;
+        plural: string;
+    };
+    properties: Record<string, LimeProperty>;
+    /**
+     * Get a property by name
+     *
+     * @param {string} name name of property to get. Allows a path to be
+     * specified using dot notation to get properties of relations
+     *
+     * @throws Will throw an error containing the name of the missing property
+     * @returns {LimeProperty} the property specified by the name argument
+     *
+     * @example
+     * const phoneProperty = dealLimetype.getProperty('company.phone')
+     */
+    getProperty(name: string): LimeProperty;
+}

package/dist/limetype/limetype.js

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

package/dist/limetype/property.d.ts

@@ -0,0 +1,32 @@
+import { Acl } from './acl';
+import { LimeType } from './limetype';
+export interface LimeProperty {
+    acl: Acl;
+    defaultvalue: any;
+    fieldorder: number;
+    has_sql?: boolean;
+    label: string;
+    length?: number;
+    localname: string;
+    name: string;
+    required: boolean;
+    type: PropertyType;
+    options?: Option[];
+    relation?: {
+        getLimetype: () => LimeType;
+        getBackreference: () => LimeProperty;
+    };
+}
+export interface Option {
+    key: string;
+    inactive: boolean;
+    text: string;
+    order?: number;
+    id?: number;
+}
+export declare type PropertyType = 'string' | 'text' | 'phone' | 'integer' | 'decimal' | 'percent' | 'time' | 'timeofday' | 'date' | 'year' | 'quarter' | 'month' | 'yesno' | 'link' | 'user' | 'xml' | 'option' | 'set' | 'file' | 'hasone' | 'hasmany' | 'belongsto' | 'hasandbelongstomany' | 'system';
+export declare function isRelation(property: LimeProperty): boolean;
+export declare function isSingleRelation(property: LimeProperty): boolean;
+export declare function isDate(property: LimeProperty): boolean;
+export declare function isString(property: LimeProperty): boolean;
+export declare function isFloat(property: LimeProperty): boolean;

package/dist/limetype/property.js

@@ -0,0 +1,32 @@
+export function isRelation(property) {
+    const propTypes = [
+        'belongsto',
+        'hasone',
+        'hasmany',
+        'hasandbelongstomany',
+    ];
+    return property && propTypes.includes(property.type);
+}
+export function isSingleRelation(property) {
+    const propTypes = ['belongsto', 'hasone'];
+    return property && propTypes.includes(property.type);
+}
+export function isDate(property) {
+    const propTypes = [
+        'time',
+        'timeofday',
+        'date',
+        'year',
+        'quarter',
+        'month',
+    ];
+    return property && propTypes.includes(property.type);
+}
+export function isString(property) {
+    const propTypes = ['string', 'text', 'phone', 'link'];
+    return property && propTypes.includes(property.type);
+}
+export function isFloat(property) {
+    const propTypes = ['decimal', 'percent'];
+    return property && propTypes.includes(property.type);
+}

package/dist/limetype/types.d.ts

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

package/dist/limetype/types.js

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

package/dist/navigator/decorator.d.ts

@@ -0,0 +1,18 @@
+import { ContextAwareStateOptions } from '../core';
+/**
+ * Config for the {@link SelectQueryParam} decorator
+ */
+export interface SelectQueryParamOptions extends ContextAwareStateOptions {
+    /**
+     * The query param to select
+     */
+    selector: string;
+}
+/**
+ * Gets a named query param from the location
+ *
+ * @experimental
+ * @param {StateOptions} options state decorator options
+ * @returns {PropertyDecorator} state decorator
+ */
+export declare function SelectQueryParam(options: SelectQueryParamOptions): PropertyDecorator;

package/dist/navigator/decorator.js

@@ -0,0 +1,15 @@
+import { PlatformServiceName } from '../core';
+import { createStateDecorator, } from '../core/decorators/factory';
+/**
+ * Gets a named query param from the location
+ *
+ * @experimental
+ * @param {StateOptions} options state decorator options
+ * @returns {PropertyDecorator} state decorator
+ */
+export function SelectQueryParam(options) {
+    const config = {
+        name: PlatformServiceName.Navigator,
+    };
+    return createStateDecorator(Object.assign({ context: null }, options), config);
+}

package/dist/navigator/index.d.ts

@@ -0,0 +1,3 @@
+export * from './navigator';
+export * from './types';
+export * from './decorator';

package/dist/navigator/index.js

@@ -0,0 +1,3 @@
+export * from './navigator';
+export * from './types';
+export * from './decorator';