@ws-ui/shared 0.0.30 → 0.0.31

package/dist/declarations/datasources/cache.d.ts

@@ -0,0 +1,26 @@
+declare namespace datasources {
+  class EntityCacheEntry<T extends IEntity = IEntity> {
+    constructor(inTimeStamp: Date, inRawEntry: T, inStamp: number);
+    GetTimeStamp(): Date;
+  }
+
+  class EntityCache<T extends IEntity = IEntity> {
+    fMaxEntities: number;
+    fTimeOut: number;
+    fCurStamp: number;
+    fCache: number;
+
+    getNextStamp(): number;
+    makeRoomFor(nbEntites: number): void;
+    clear(nbToClear: number): void;
+    clearAll(): void;
+    setEntry(inKey: string, inRawEntry: T, inTimeStamp: Date);
+    retainEntry(inKey: string, inCacheDelay: number): T;
+    removeEntry(inKey: string): void;
+    setMaxEntries(nbentries: number, canReduce: boolean): void;
+    setTimeOut(inTimeout: number): void;
+
+    static cloneRawEntity(rawEntityDef: T): T;
+    static getTimeStamp(): Date;
+  }
+}

package/dist/declarations/datasources/dataclass.d.ts

@@ -0,0 +1,47 @@
+declare namespace datasources {
+  interface IDataClassPrivate<T extends IEntity = IEntity> {
+    datastore: ICatalog;
+    className: string;
+    exposed?: boolean;
+    attributes: {
+      [attributeName: string]: IDataClassAttribute;
+    };
+    collectionName: string;
+    cache: EntityCache<T>;
+    keys: string[];
+  }
+
+  type IGetEntitySettings = Partial<{
+    expand: string;
+    filterAttributes: string;
+  }>;
+
+  class DataClass<T extends IEntity = IEntity> {
+    _private: IDataClassPrivate<T>;
+    constructor(rawDef: IDetailedDataClass, owner: ICatalog);
+    getName(): string;
+    getCollectionName(): string;
+    getDataStore(): ICatalog;
+    getAttribute(attname: string): IDataClassAttribute | null;
+    getAllAttributes(): {
+      [attributeName: string]: IDataClassAttribute;
+    };
+    getEntity(primKey: string, settings?: IGetEntitySettings): Promise<T>;
+    query(
+      queryStr: string,
+      settings?: IEntitySelectionSettings,
+    ): EntitySelection<T>;
+    getDistinctValues(
+      attName: string,
+      maxElems?: number,
+      queryFilter?: string,
+    ): Promise<string[]>;
+    allEntities(settings: IEntitySelectionSettings): EntitySelection<T>;
+    newEmptySelection(): EntitySelection<T>;
+    getCacheDelay(): number;
+    getCache(): EntityCache<T>;
+    getKeys(): string[];
+    isExposed(): boolean;
+    supportJSONEntityKey(): boolean;
+  }
+}

package/dist/declarations/datasources/datasource.d.ts

@@ -0,0 +1,356 @@
+declare namespace datasources {
+  type TEventData = import('~/hooks/use-events/interfaces').webforms.WEvent;
+  type TDatasourceType =
+    | 'auto'
+    | 'entity'
+    | 'entitysel'
+    | 'catalog'
+    | 'dataclass'
+    | 'scalar'
+    | 'array'
+    | 'object';
+  type TJSType = 'string' | 'number' | 'bool' | 'date' | 'object' | 'array';
+  type TDataType =
+    | 'array'
+    | 'bool'
+    | 'string'
+    | 'text'
+    | 'uuid'
+    | 'short'
+    | 'long'
+    | 'number'
+    | 'long64'
+    | 'duration'
+    | 'object'
+    | 'date'
+    | 'image';
+  interface IEnhancedCatalog extends ICatalog {
+    dataClasses: IDataClasses;
+    dataClassByCollectionName: IDataClasses;
+  }
+  interface ICollection<T extends IEntity = IEntity> {
+    __COUNT: number;
+    __DATACLASS: string;
+    __FIRST: number;
+    __GlobalStamp: number;
+    __SENT: string;
+    __entityModel: string;
+    __ENTITIES: T[];
+    __ENTITYSET?: string;
+    __MAXENTITIES?: number;
+    __queryPlan?: any;
+    __extendedQueryPlan?: any;
+    __extendedQueryPath?: any;
+  }
+
+  interface IBaseAttribute {
+    name: string;
+    kind: AttributeKind;
+    scope: Scope;
+    exposed?: boolean;
+    readOnly?: boolean;
+  }
+  interface ISimpleAttribute extends IBaseAttribute {
+    type: AttributeType;
+    indexed?: boolean;
+    identifying?: boolean;
+    simpleDate?: boolean;
+  }
+
+  interface IRelatedEntitiesAttribute extends IBaseAttribute {
+    kind: 'relatedEntities';
+    path: string;
+    type: AttributeType | string;
+    inverseName: string;
+    reversePath: boolean;
+  }
+
+  interface IRelatedEntityAttribute extends IBaseAttribute {
+    kind: 'relatedEntity';
+    type: AttributeType | string;
+    path: string;
+    foreignKey: string;
+    inverseName: string;
+  }
+
+  interface ICalculatedAttribute extends IBaseAttribute {
+    kind: 'calculated';
+    type: AttributeType | string;
+    foreignKey?: string;
+    inverseName?: string;
+    reversePath?: boolean;
+    path?: string;
+    behavior?: 'relatedEntities' | 'relatedEntity';
+  }
+
+  interface IAliasAttribute extends IBaseAttribute {
+    behavior?: 'relatedEntities' | 'relatedEntity';
+    type: AttributeType | string;
+    foreignKey?: string;
+    inverseName?: string;
+    reversePath?: boolean;
+    path?: string;
+    kind: 'alias';
+  }
+
+  type IAttribute = {
+    name: string;
+    type: string;
+    kind: EAttributeKind;
+    scope: AttributeScope;
+  } & Partial<{
+    indexKind: TIndexType;
+    autogenerate: boolean;
+    unique: boolean;
+    primKey: boolean;
+    exposed: boolean;
+    behavior: string;
+    autosequence: boolean;
+    reversePath: boolean;
+    not_null: boolean;
+    minValue: number;
+    maxValue: number;
+    simpleDate: boolean;
+    defaultValue: any;
+    events: any[];
+    path: string;
+    extraProperties: IAttributeProperties;
+    styled_text: boolean;
+  }>;
+
+  interface IRelatedAttribute extends IBaseAttribute {
+    type?: AttributeType | string;
+    behavior: 'relatedEntities' | 'relatedEntity';
+    foreignKey?: string;
+    inverseName?: string;
+    path?: string;
+    reversePath?: boolean;
+  }
+  interface IEntity {
+    __KEY?: string;
+    __TIMESTAMP?: Date;
+    __STAMP?: number;
+  }
+  interface ICatalog {
+    __UNIQID: string;
+    __BASEID: string;
+    methods: catalog.IMethod[];
+    dataClasses: IDetailedDataClass[];
+  }
+
+  interface IDataClass {
+    name: string;
+    uri: string;
+    dataURI: string;
+  }
+  interface IDetailedDataClass extends IDataClass {
+    className: string;
+    collectionName: string;
+    tableNumber: number;
+    scope: Scope;
+    attributes?: IAttribute[];
+    key: IDataClassKey[];
+    methods: catalog.IMethod[];
+    exposed?: boolean;
+  }
+
+  type IDataClasses = { [key: string]: IDetailedDataClass };
+
+  class AttributeFilter {
+    addAttribute(attname: string, subfilter?: any): void;
+    mergeWith(mergeWith: { filter: any }): void;
+    addFilterText(filterText: string, newprop: string): string;
+    buildString(curpath: string): String;
+  }
+
+  interface IDSChildren {
+    [datasourceName: string]: DataSource;
+  }
+
+  interface INameSpace {
+    sources: IDSChildren;
+    root: DataSource;
+  }
+  type ICreateDataSource =
+    | ICreateDataSourceScalar
+    | ICreateDataSourceArray
+    | ICreateDataSourceObject
+    | ICreateDataSourceEntity
+    | ICreateDataSourceEntitySelection;
+  type IEntityDatasource =
+    | datasources.ICreateDataSourceEntity
+    | datasources.ICreateDataSourceEntitySelection;
+
+  interface ICreateDataSourceCommon {
+    id: string;
+    initialValue: any;
+    events?: webforms.WEvent[];
+    namespace: string;
+  }
+
+  interface ICreateDataSourceScalar extends ICreateDataSourceCommon {
+    type: 'scalar';
+    initialValue?: string | boolean | number | any[] | object | null;
+    dataType: TJSType;
+    from?: string;
+  }
+
+  interface ICreateDataSourceArray extends ICreateDataSourceCommon {
+    id: string;
+    type: 'scalar';
+    initialValue: any[] | null;
+    dataType: 'array';
+    from?: string;
+  }
+  interface ICreateDataSourceObject extends ICreateDataSourceCommon {
+    type: 'scalar';
+    initialValue: object | null;
+    dataType: 'object';
+    from?: string;
+  }
+  interface ICreateDataSourceEntity extends ICreateDataSourceCommon {
+    type: 'entity';
+    initialValue: 'first' | '';
+    dataclass: string;
+    depth: number | null;
+    from?: string;
+    dataType?: string;
+  }
+  interface ICreateDataSourceEntitySelection extends ICreateDataSourceCommon {
+    type: 'entitysel';
+    initialValue: 'all' | '';
+    from?: string;
+    dataclass: string;
+    depth: number | null;
+    pageSize: number | null;
+    dataType?: string;
+  }
+  interface IDSMethods {
+    [key: string]: catalog.IMethod;
+  }
+
+  class DataSource {
+    id: string;
+    alias: string;
+    type: TDatasourceType;
+    namespace: string;
+    stamp: number;
+    frozenStamp: number;
+    inited: boolean;
+    beeingResolved: boolean;
+    fromServerStorage: boolean;
+    canBeUpdatedByParent: boolean;
+    local: boolean;
+    parentSource: this;
+    dataType: TJSType;
+    dataclass: datasources.DataClass;
+    dataclassID: string;
+    parendId: string;
+    children: IDSChildren;
+    initialValue: string | null;
+    properyInParent?: string;
+    filterAttributes?: AttributeFilter;
+    filterAttributesText?: string;
+
+    constructor(namespace: string, id: string, type: string);
+    static spaces: {
+      [namespace: string]: INameSpace;
+    };
+    static globalStamp: number;
+    static anonymCount: number;
+    static dataTypeMap: {
+      bool: 'bool';
+      string: 'string';
+      text: 'string';
+      uuid: 'string';
+      short: 'number';
+      long: 'number';
+      number: 'number';
+      long64: 'number';
+      duration: 'number';
+      object: 'object';
+      date: 'date';
+    };
+    static getOrBuildNameSpace(namespace?: string): INameSpace;
+    static getNameSpace(namespace: string): INameSpace;
+    static buildSource(
+      sourcestr: string,
+      initialValue: any,
+      ds: DataStore,
+      namespace: string,
+    ): void;
+    static create(
+      settings: ICreateDataSource,
+      ds: DataStore,
+      namespace?: string,
+    ): DataSource;
+    static getSourceAttributes(
+      id: string,
+      options?: any,
+      namespace?: string,
+    ): IDataClassAttribute[];
+    static buildCatalogDatasources(
+      datastore: datasources.DataStore,
+      namespace?: string,
+    );
+    isLocal(): boolean;
+    setLocal(local: boolean): void;
+    buildCallFuncURL(
+      methodName: string,
+      added: string,
+    ): string | Promise<string>;
+    buildEntitySettings(existingSettings?: any): any;
+    fireEvent(eventType: string, data?: any): void;
+    addListener(eventType: string, callback: Function): void;
+    removeListener(eventType: string, callback: Function): void;
+    getValue<T = any>(property?: string | number, settings?: any): Promise<T>;
+    findElementPosition(elementDataSource: DataSource): Promise<number>;
+    getCollection<T extends IEntity = IEntity>(
+      index: number,
+      howmany: number,
+      propertyStr: string,
+    ): Promise<T[]>;
+    orderBy(attrs: string): Promise<null>;
+    getValueAsParam(property: string, settings: any): Promise<null>;
+    getDataType(): null;
+    setValue<T = any>(
+      property: string | null,
+      value: T,
+      doFireEvent?: boolean,
+    ): Promise<void>;
+    setValueFromMethodResult(resp: any, doFireEvent?: boolean): Promise<void>;
+    clone(): null;
+    refresh(doFireEvent?: boolean): Promise<void>;
+    recompute(fireEvent?: boolean): Promise<void>;
+    recomputeChildren(doFireEvent?: boolean): Promise<void>;
+    addAttributeFilter(child: this): void;
+    static createRequestOptimization(ns?: string): void;
+    formatValue(value: any): typeof value;
+    getStamp(): number;
+    touch(): void;
+    getParentSource(): this;
+    getDataClass(): DataClass;
+    getProperyInParent(): string;
+    freezeStamp(withChildren: boolean): void;
+    modifiedSinceLastFreeze(): boolean;
+    dumpTree(curtext: string, level: number): string;
+    init(): void;
+    filterAttributesText?: string;
+    callAction?(action: string, meta?: any): void;
+    getMethods(): IDSMethods;
+    copyValueInto(source: any, fireEvent?: boolean): Promise<void>;
+    static getSource(id: string, namespace?: string): DataSource | undefined;
+    static getSource(id: string, namespace?: string): DataSource | undefined;
+    static getSourceOrBuild(
+      id: string | null,
+      initialValue: any,
+      ds: DataStore,
+      namespace?: string,
+    ): DataSource;
+    static AddAlias(id: string, datasource: DataSource, namespace?: string);
+    static buildDependencies(namespace?: string): void;
+    static computeInitialValues(namespace?: string): void;
+    static refreshNamespace(namespace?: string): void;
+    static getAllSources(namespace?: string): IDSChildren | {};
+  }
+}

package/dist/declarations/datasources/datastore.d.ts

@@ -0,0 +1,61 @@
+declare namespace datasources {
+  class ProgressIndicator {
+    refID: string;
+    started: Date;
+    lastChecked: number;
+    inited: boolean;
+    checkDeletedCount: number;
+    askedToStop: boolean;
+    graceFullStop: boolean;
+
+    getRefID(): string;
+    userAbort(): void;
+    stopGracefully(): void;
+
+    static InitManager(): void;
+    static register(progress: ProgressIndicator): void;
+    static unregister(progress: ProgressIndicator): void;
+    static getProgress(refID: string): ProgressIndicator;
+    static addListener(handler: Function): number;
+    static removeListener(id: string): void;
+    static tellListeners(command: string, progress: ProgressIndicator): void;
+  }
+
+  interface IDataStorePrivate {
+    uniqID: string;
+    dataclasses: {
+      [dataclassName: string]: DataClass;
+    };
+    dataclassesByCollectionName: {
+      [collectionName: string]: DataClass;
+    };
+    cacheDelay: number;
+  }
+
+  class DataStore {
+    _private: IDataClassPrivate;
+    constructor(ID: string);
+    fetch(): Promise<this>;
+    getUniqID(): string;
+    getBaseID(): string;
+    getDataClass(classname: string): DataClass;
+    getDataClassByCollectionName(collectionName: string): DataClass;
+    getCacheDelay(): number;
+    getDataClasses(): {
+      [dataclassName: string]: DataClass;
+    };
+    initProgressManager(): void;
+    newProgressIndicator(): ProgressIndicator;
+    addProgressListener(handler: Function): void;
+    removeProgressListener(id: string): void;
+    getProjectName(): string;
+    getMethods(): {
+      [key: string]: {
+        name: string;
+        exposed: boolean;
+        allowedOnHTTPGET: boolean;
+      };
+    };
+    HTMLEncode(source: string, display: boolean, tabs: number): string;
+  }
+}

package/dist/declarations/datasources/entitysel.d.ts

@@ -0,0 +1,68 @@
+declare namespace datasources {
+  interface ICurrentPage<T extends IEntity = IEntity> {
+    first: number;
+    size: number;
+    entitiesDef: T[];
+  }
+
+  type IEntitySelectionSettings = Partial<{
+    expand: string;
+    relatedSelURI: string;
+    queryStr: string;
+    queryParams: string;
+    first: number;
+    pageLength: number;
+    filterAttributes: string;
+    dataSetName: string;
+  }>;
+
+  interface IEntitySelectionPrivate<T extends IEntity = IEntity> {
+    curPage: ICurrentPage<T>;
+    selLength: number;
+    maxEntities: number;
+    initialFirst: number;
+    pageLength: number;
+    inited: boolean;
+    owner: DataClass<T>;
+    fetching: boolean;
+    settings: IEntitySelectionSettings;
+    isRelatedSel: boolean;
+    relatedSelURI: string;
+    dataSetName: string;
+    filterAttributes: string;
+  }
+
+  interface IDescriptorAsParam {
+    __ENTITIES: boolean;
+    __DATACLASS: string;
+    __DATASET: string;
+  }
+
+  class EntitySelection<T extends IEntity = IEntity> {
+    constructor(
+      owner: DataClass<T>,
+      settings: IEntitySelectionSettings,
+      rawDef: IDataClass,
+    );
+
+    readonly length: number;
+    initAsEmpty(): void;
+    getLength(settings?: IEntitySelectionSettings): Promise<number>;
+    getMaxEntities(): number;
+    getDataClass(): DataClass<T>;
+    getDescriptorAsParam(): IDescriptorAsParam;
+    getComputedURL(
+      settings?: IEntitySelectionSettings,
+      forFuncCall?: boolean,
+    ): {
+      url: string;
+      added: string;
+    };
+    fetchPage(
+      first: number,
+      size: number,
+      settings?: IEntitySelectionSettings,
+    ): Promise<ICollection<T>>;
+    managePage(rawDef: ICollection<T>, nochangeInCurpage?: boolean): T[];
+  }
+}

package/dist/declarations/datasources/interfaces/catalog.d.ts

@@ -0,0 +1,112 @@
+declare namespace catalog {
+  enum EAttributeKind {
+    STORAGE = 'storage',
+    RELATEDENTITY = 'relatedEntity',
+    RELATEDENTITIES = 'relatedEntities',
+    CALCULATED = 'calculated',
+    COMPOSITION = 'composition',
+    ALIAS = 'alias',
+  }
+  type AttributeType =
+    | 'bool'
+    | 'word'
+    | 'blob'
+    | 'string'
+    | 'text'
+    | 'uuid'
+    | 'short'
+    | 'long'
+    | 'number'
+    | 'byte'
+    | 'long64'
+    | 'duration'
+    | 'object'
+    | 'date'
+    | 'image';
+  type Scope = 'public' | 'publicOnServer';
+  type ApplyTo = 'dataClass' | 'entity' | 'entityCollection' | 'dataStore';
+  type AttributeKind =
+    | 'storage'
+    | 'alias'
+    | 'calculated'
+    | 'relatedEntity'
+    | 'relatedEntities';
+
+  type IDataClassProperties = Partial<{
+    panelColor: string;
+    position: {
+      x: number;
+      y: number;
+    };
+  }>;
+  type IAttributeProperties = Partial<{}>;
+  interface IModelProperties
+    extends Partial<{
+      version: string;
+      backgroundColor: string;
+      backgroundImage: string;
+      backgroundVariant: 'dotted' | 'grid' | 'none';
+      zoom: number;
+      viewportPosition: [number, number];
+    }> {}
+  interface IMethod {
+    name: string;
+    applyTo: ApplyTo;
+    scope: Scope;
+    from: 'remoteServer';
+    allowedOnHTTPGET: boolean;
+    startingLine: number;
+    paramsText: string;
+    filePath: string;
+    userDefined: boolean;
+    endingLine: number;
+    exposed: boolean;
+  }
+  type IDataClass = {
+    name: string;
+    className: string;
+    collectionName: string;
+    scope: DataclassScope;
+    attributes: IAttribute[];
+  } & Partial<{
+    defaultTopSize: number;
+    leave_tag_on_delete: boolean;
+    prevent_journaling: boolean;
+    comment: string;
+    extraProperties: IDataClassProperties;
+  }>;
+  type IEvent = {
+    kind: string;
+    from: string;
+    userDefined: boolean;
+  };
+  export type AttributeIndexKind = 'btree' | 'cluster' | 'auto' | 'none';
+  type IAttribute = {
+    name: string;
+    type: string;
+    kind: AttributeKind;
+    scope: Scope;
+  } & Partial<{
+    indexKind?: AttributeIndexKind | null;
+    invalidAlias: boolean;
+    autogenerate: boolean;
+    unique: boolean;
+    primKey: boolean;
+    exposed: boolean;
+    behavior: string;
+    autosequence: boolean;
+    indexed: boolean;
+    reversePath: boolean;
+    keywordIndexed: boolean;
+    not_null: boolean; // TODO: to be renamed to mandatory
+    minValue: number;
+    maxValue: number;
+    simpleDate: boolean;
+    defaultValue: any;
+    events: any[];
+    path: string;
+    extraProperties: IAttributeProperties;
+    styled_text: boolean;
+    comment: string;
+  }>;
+}

package/dist/declarations/datasources/interfaces/dataclass-attribute.d.ts

@@ -0,0 +1,88 @@
+declare namespace catalog {
+  interface AttributeProps {
+    indexKind: AttributeIndexKind;
+    autogenerate: boolean;
+    unique: boolean;
+    primKey: boolean;
+    exposed: boolean;
+    autosequence: boolean;
+    keywordIndexed: boolean;
+    not_null: boolean; // TODO: to be renamed to mandatory
+    minValue: number;
+    maxValue: number;
+    simpleDate: boolean;
+    defaultValue: any;
+    extraProperties: IAttributeProperties;
+    styled_text: boolean;
+    comment: string;
+    events: any[];
+  }
+  interface BaseAttribute extends Partial<AttributeProps> {
+    /**
+     * name of the attribute
+     */
+    name: string;
+    /**
+     * represents the actual type of the attribute (storage, relatedentity, relatedEntities, alias, calculated);
+     */
+    kind: AttributeKind;
+    /**
+     * Scope of the attribute (publicOnServer is equivalent to private)
+     */
+    scope: Scope;
+  }
+
+  interface StorageAttribute extends BaseAttribute {
+    kind: 'storage';
+    type: AttributeType;
+  }
+
+  interface RelatedEntityAttribute extends BaseAttribute {
+    kind: 'relatedEntity';
+    /**
+     * the value for the type property is the name of originating dataclass.
+     */
+    type: string;
+  }
+
+  interface RelatedEntitiesAttribute extends BaseAttribute {
+    kind: 'relatedEntities';
+    /**
+     * the value for the type property is the `selection name` of originating dataclass.
+     */
+    type: string;
+    /**
+     * the path to the related attribute in the originating dataclass.
+     */
+    path: string;
+    reversePath?: boolean;
+  }
+
+  interface AliasAttribute extends BaseAttribute {
+    kind: 'alias';
+    /**
+     * in the case of alias, the type can be:
+     * - storage type. (bool, number, string, ...etc)
+     * - the `name` of the dataclass in case `behavior` is set to `relatedEntity`
+     * - the `selection name` of the dataclass in case `behavior` is set to `relatedEntities`
+     */
+    type: string;
+    path: string;
+    behavior?: 'relatedEntity' | 'relatedEntities';
+    reversePath?: string;
+  }
+
+  interface CalculatedAttribute extends BaseAttribute {
+    kind: 'calculated';
+    type: string;
+    path?: string;
+    behavior?: 'relatedEntity' | 'relatedEntities';
+  }
+
+  type Attribute =
+    | StorageAttribute
+    | RelatedEntityAttribute
+    | RelatedEntitiesAttribute
+    | AliasAttribute
+    | CalculatedAttribute;
+}

package/dist/declarations/datasources/methods.d.ts

@@ -0,0 +1,71 @@
+declare namespace datasources {
+  interface IComponentAction {
+    [actionName: string]: {
+      stamp: number;
+      value: any;
+    };
+  }
+
+  class Utils {
+    static formatValue(value: number | string | Date, format: string): string;
+    static formatString(value: string, format: string): string;
+    static formatDuration(value: number): string;
+    static convertAs(dataType: string, value: string);
+    static stringToNumber(value: string): string;
+    static entityKeyToJSON(key: string): string;
+    static initFramework(): Promise<void>;
+  }
+  class Method4D {
+    acceptedEvents: {
+      [event: string]: boolean;
+    };
+    constructor(
+      methodName: string,
+      resultSource: datasources.DataSource,
+      paramSources: datasources.DataSource[],
+      owenerSource: datasources.DataSource | null,
+    );
+    static buildMethod(
+      component: {
+        methodName: string;
+        resultingDataSource: Partial<{
+          id: string;
+          namespace: string;
+        }>;
+        parameters: {
+          name: string;
+          namespace?: string;
+          isHardCoded?: boolean;
+          type?: 'date' | 'string' | 'object' | 'array' | 'number' | 'bool';
+        }[];
+      },
+      associatedData: { namespace: string },
+      ownerSource: DataSource | null,
+    ): Method4D;
+    static buildAction(component: { action: string }): string;
+    static buildEvents(component: { eventType: string }): {
+      [evName: string]: boolean;
+    };
+    static validEvent(event: string): boolean;
+    static replaceDataSources(
+      component: { parameters: any },
+      elemSource,
+      newid: string,
+    );
+
+    callServerSide(
+      widget: {
+        id?: string;
+        serverSideRef?: string;
+      },
+      callerType: string,
+      additionalData?: any,
+      addOwnerSourceAsParam?: boolean,
+      callFuncUrl?: string,
+    ): Promise<{
+      [refName: string]: IComponentAction;
+      __NOTIFICATION?: { message: string; type: string };
+    }>;
+    isMemberFunction(): boolean;
+  }
+}

package/dist/declarations/datasources/rest.d.ts

@@ -0,0 +1,18 @@
+declare namespace datasources {
+  class RestError extends Error {
+    constructor(
+      public message: string,
+      public status: number,
+      public statusText?: string,
+      public errCode?: number | string,
+    );
+
+    getDescription(): string;
+  }
+
+  function restRequest<T>(
+    command: HttpMethod,
+    url: string,
+    body: any,
+  ): Promise<T>;
+}

package/dist/declarations/http-methods.d.ts

@@ -0,0 +1,70 @@
+declare namespace http {
+  /**
+   * Hypertext Transfer Protocol (HTTP) request method names.
+   * @see {@link https://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods}
+   */
+  enum HttpMethod {
+    /**
+     * The GET method requests a representation of the specified resource.
+     * Requests using GET should only retrieve data and should have no other effect.
+     * (This is also true of some other HTTP methods.)
+     *
+     * The W3C has published guidance principles on this distinction, saying,
+     * "Web application design should be informed by the above principles,
+     * but also by the relevant limitations.".
+     */
+    GET = 'GET',
+    /**
+     * The HEAD method asks for a response identical to that of a GET request,
+     * but without the response body.
+     *
+     * This is useful for retrieving meta-information written in response headers,
+     * without having to transport the entire content.
+     */
+    HEAD = 'HEAD',
+    /**
+     * The POST method requests that the server accept the entity enclosed in the
+     * request as a new subordinate of the web resource identified by the URI.
+     * The data POSTed might be, for example, an annotation for existing resources;
+     * a message for a bulletin board, newsgroup, mailing list, or comment thread;
+     * a block of data that is the result of submitting a web form to a
+     * data-handling process; or an item to add to a database.
+     */
+    POST = 'POST',
+    /**
+     * The PUT method requests that the enclosed entity be stored under the supplied
+     * URI.
+     *
+     * If the URI refers to an already existing resource, it is modified; if the
+     * URI does not point to an existing resource, then the server can create the
+     * resource with that URI.
+     */
+    PUT = 'PUT',
+    /**
+     * The DELETE method deletes the specified resource.
+     */
+    DELETE = 'DELETE',
+    /**
+     * The TRACE method echoes the received request so that a client can see what
+     * (if any) changes or additions have been made by intermediate servers.
+     */
+    TRACE = 'TRACE',
+    /**
+     * The OPTIONS method returns the HTTP methods that the server supports for
+     * the specified URL.
+     * This can be used to check the functionality of a web server by requesting '*'
+     * instead of a specific resource.
+     */
+    OPTIONS = 'OPTIONS',
+    /**
+     * The CONNECT method converts the request connection to a transparent TCP/IP
+     * tunnel, usually to facilitate SSL-encrypted communication (HTTPS) through
+     * an unencrypted HTTP proxy.
+     */
+    CONNECT = 'CONNECT',
+    /**
+     * The PATCH method applies partial modifications to a resource.
+     */
+    PATCH = 'PATCH',
+  }
+}

package/dist/declarations/index.d.ts

@@ -0,0 +1,41 @@
+declare var DataSource: typeof datasources.DataSource;
+declare var Method4D: typeof datasources.Method4D;
+declare var Utils: typeof datasources.Utils;
+declare var $$datastores: {
+  [dsName: string]: datasources.DataStore;
+};
+
+declare module 'CustomComponents/list' {
+  declare var components: {
+    [key: string]: any;
+  };
+}
+
+declare module 'css-box-shadow' {
+  declare function parse(value: string): {
+    inset: 'inset' | null;
+    offsetX: number;
+    offsetY: number;
+    blurRadius: number;
+    spreadRadius: number;
+    color: string;
+  }[];
+  declare function stringify(args: any[]);
+}
+
+declare var dragOutData: {
+  dragOut: boolean;
+  lastNodesId: string;
+} = {
+  dragOut: false,
+  lastNodesId: '',
+};
+
+declare global {
+  interface Window {
+    dragOutData: {
+      dragOut: boolean;
+      lastNodesId: string;
+    };
+  }
+}

package/dist/declarations/webform/webform.d.ts

@@ -0,0 +1,223 @@
+declare namespace webforms {
+  type ReactCSSProperties = import('react').CSSProperties;
+  type CraftComponent = import('@ws-ui/craftjs-core').SerializedNode;
+
+  type ComponentProps<CSSProperties = ReactCSSProperties> = {
+    moveable?: boolean;
+    deletable?: boolean;
+    className?: string;
+    role?: string;
+    /**
+     * A reference used to perform server side actions on the element based on a server call response.
+     */
+    serverSideRef?: string;
+    /**
+     * list of css properties that will be applied to the element by the user.
+     */
+    style?: CSSProperties;
+    /**
+     * Contains the list of events listeners that will be applied to the element during the runtime.
+     */
+    events?: WEvent[];
+    /**
+     * Contains list of classnames that have been applied to the element by the user
+     */
+    classNames?: string[];
+    /**
+     * Represants the main datasource for the component.
+     *
+     * It can contain multiple datasources paths separated by commas.
+     *
+     * Datasource Paths syntax: _`namespace`_ __:__ _`datasource.attribute1....attributeN`_
+     */
+    datasource?: string;
+    /**
+     * Represants the current element datasource for the component.
+     *
+     * It is usually used for items dealing with a list of items.
+     *
+     * It can only contain a single datasource path.
+     *
+     * Datasource Paths syntax: _`namespace`_ __:__ _`datasource.attribute1....attributeN`_
+     */
+    currentElement?: string;
+    /**
+     * Defines if the component is iterable.
+     *
+     * An iterable component must use the 'iterator' property.
+     */
+    iterable?: boolean;
+    /**
+     * Defines if the component is loopable.
+     *
+     * Used on Datatable component (which does not support the iterator property yet).
+     */
+    loopable?: boolean;
+    /**
+     * Represants the iterator key for the component.
+     *
+     * Used on components like Matrix & Select Box.
+     */
+    iterator?: string;
+  };
+
+  type Info = {
+    displayName: string;
+    icon?: React.FC<any>;
+    exposed?: boolean;
+    isCanvas?: boolean;
+    events: EventMeta[];
+    iconName?: string;
+    tipKey?: string;
+    kind?: 'user' | 'basic' | 'template';
+    sanityCheck?: {
+      keys: {
+        name: string | Array<ISanityCheckElement>;
+        isDatasource: boolean;
+        require: boolean;
+      }[];
+    };
+  };
+
+  type StyleClass = {
+    /**
+     * Unique id for the class.
+     */
+    id: string;
+    /**
+     * Scope of the classe.
+     * values: 'shared', 'theme', 'local'
+     */
+    scope: 'shared' | 'theme' | 'local';
+    /**
+     * Name of the class
+     */
+    name: string;
+    /**
+     * content of the class.
+     */
+    content: string;
+    /**
+     * an id of the parent class. should be null if the class is not associated with any other class.
+     */
+    parentId: string | null;
+    /**
+     * An object of linked style classes.
+     *
+     * onDrop of the class on a component, if the component has a linked node,
+     * it will be assigned a style class if it's type is declared in this object.
+     *
+     * key: represents the type of component to be associated with style class on drop.
+     *
+     * value: id of the associated style class.
+     */
+    children?: {
+      [key: string]: string;
+    };
+    /**
+     * defines the origin of the style class from which it was exported.
+     */
+    origin?: string;
+  };
+
+  type Datasources = datasources.ICreateDataSource[];
+
+  type Metadata = Partial<{
+    v: string;
+    datasources: Datasources;
+    styles: StyleClass[];
+    title: string;
+  }>;
+
+  type Content = {
+    components: Record<string, CraftComponent>;
+    metadata?: Metadata;
+  };
+
+  // ------------------ EVENTS --------------------------
+  type WEvent = MemberFunctionEvent | NavigationEvent | SimpleActionEvent;
+
+  interface BaseEvent {
+    id: string;
+    events: string[];
+    type: 'method' | 'navigation' | 'simple-action';
+    disabled?: boolean;
+  }
+
+  interface MemberFunctionEvent extends BaseEvent {
+    type: 'method';
+    method?: string;
+    dataclass?: string;
+    params: MethodParam[];
+    returns?: Omit<MethodParam, 'id'>;
+    namespace?: string;
+    code?: string;
+    feedback?: boolean;
+    datasource?: string;
+  }
+
+  interface SimpleActionEvent extends BaseEvent {
+    type: 'simple-action';
+    datasource: {
+      name: string;
+      type?: datasources.ICreateDataSource['type'] | 'unknown';
+      dataType?: datasources.ICreateDataSource['dataType'];
+      namespace?: string;
+      from?: string;
+      target?: string;
+      targetNamespace?: string;
+      targetType?: string;
+    };
+    action: string;
+    query?: QueryString;
+    orderBy?: OrderBy[];
+    feedback?: {
+      enabled?: boolean;
+      messages?: { onSuccess?: string; onFail?: string };
+    };
+  }
+
+  interface NavigationEvent extends BaseEvent {
+    type: 'navigation';
+    parent: string;
+    loader: string;
+    target: string;
+    externalLink: boolean;
+  }
+
+  interface EventMeta {
+    label: string;
+    value: string;
+  }
+  type HardCodedType =
+    | 'date'
+    | 'string'
+    | 'object'
+    | 'number'
+    | 'bool'
+    | 'array';
+  type MethodParam = {
+    id: string;
+    name?: string;
+    datasource?: string;
+    type?: string;
+    isHardCoded?: boolean;
+    hardCodedType?: HardCodedTypes;
+    hardCodedValue?: string;
+  };
+
+  type MethodReturn = Omit<MethodParam, 'name'>;
+
+  interface QueryParam extends MethodParam {}
+
+  interface OrderBy {
+    name: string; // replace with attribute
+    order: 'asc' | 'desc';
+    id: string;
+  }
+
+  interface QueryString {
+    query?: string; // query
+    params?: QueryParam[];
+  }
+}

package/dist/tailwind.preset.js

@@ -0,0 +1,143 @@
+// Tailwind preset
+module.exports = {
+  theme: {
+    extend: {
+      colors: {
+        'fd-gray': {
+          lighter: '#EAEAEA',
+          light: '#444444',
+          default: '#313131',
+          mild: '#B3B3B3',
+          dark: '#222222',
+          darker: '#151515',
+        },
+        'fd-blue': {
+          lighter: '#03bbff',
+          light: '#168EDB',
+          default: '#004289',
+        },
+        'fd-orange': {
+          default: 'rgb(172, 110, 17)',
+        },
+        'fd-custom': {
+          'light-blue': '#BADFFF',
+          'dark-blue': '005BA9',
+        },
+        'fd-purple': {
+          lighter: '#CDB7FA',
+          darker: '#6A22FC',
+          default: '#CDB7FA',
+        },
+        grey: {
+          50: '#F1F5F9',
+          100: '#CCCCCC',
+          200: '#888888',
+          300: '#535353',
+          400: '#484848',
+          500: '#444444',
+          600: '#3F3F3F',
+          700: '#393939',
+          800: '#383838',
+          900: '#262626',
+        },
+        blue: {
+          400: '#1D9DFF',
+          900: '#074289',
+        },
+        red: {
+          500: '#CE5151',
+          600: '#FB7373',
+        },
+        primary: {
+          light: '#E8C3FF',
+          dark: '#B174E5',
+          darker: '#925FBE',
+          DEFAULT: '#BB0BD1',
+          hover: '#633A85',
+        },
+        purple: {
+          50: '#F2DDFF',
+          100: '#EDD0FF',
+          200: '#E8C3FF',
+          300: '#E3B7FF',
+          400: '#D99FFD',
+          500: '#C683FF',
+          600: '#B174E5',
+          700: '#A15FD8',
+          800: '#925FBE',
+          900: '#BB0BD1',
+        },
+      },
+      fontFamily: {
+        'open-sans': ['Poppins', 'Open Sans', 'sans-serif'],
+        roboto: ['Roboto', 'sans-serif'],
+        poppins: ['Poppins', 'sans-serif'],
+      },
+      fontSize: {
+        xxs: '.55rem',
+        xs: '.65rem',
+        s: '.75rem',
+      },
+      cursor: {
+        grab: 'grab',
+      },
+      outlineWidth: {
+        xxs: '0.1px',
+        xs: '0.3px',
+        s: '0.5px',
+      },
+      typography: (theme) => ({
+        sm: {
+          css: {
+            h1: {
+              color: theme('colors.white'),
+            },
+            h2: {
+              color: theme('colors.white'),
+            },
+            h3: {
+              color: theme('colors.white'),
+              'margin-top': '0px',
+            },
+            h4: {
+              color: theme('colors.white'),
+            },
+            strong: {
+              color: theme('colors.grey.100'),
+            },
+            a: {
+              color: theme('colors.blue.200'),
+            },
+            blockquote: {
+              color: theme('colors.grey.100'),
+            },
+            img: {
+              'margin-top': '5px',
+              'margin-bottom': '5px',
+            },
+          },
+        },
+      }),
+      borderRadius: {
+        DEFAULT: '4px',
+      },
+      boxShadow: {
+        toolbar: '0px 3px 6px #00000029',
+      },
+      minHeight: {
+        6: '1.5rem',
+      },
+      height: {
+        4.5: '1.125rem',
+      },
+      divideWidth: {
+        DEFAULT: '0.5px',
+      },
+      borderWidth: {
+        DEFAULT: '0.5px',
+        px: '1px',
+      },
+    },
+  },
+  plugins: [require('@tailwindcss/typography')],
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ws-ui/shared",
   "private": false,
-  "version": "0.0.30",
+  "version": "0.0.31",
   "type": "module",
   "main": "./dist/index.cjs.js",
   "module": "./dist/index.es.js",