@acorex/platform 1.0.0

package/schema/lib/operators.d.ts

@@ -0,0 +1,22 @@
+export interface AXPFilterOperator {
+    name: string;
+    title: string;
+    hasValue: boolean;
+}
+export declare const EQ_OPER: AXPFilterOperator;
+export declare const NOT_EQ_OPER: AXPFilterOperator;
+export declare const GT_OPER: AXPFilterOperator;
+export declare const LT_OPER: AXPFilterOperator;
+export declare const GTE_OPER: AXPFilterOperator;
+export declare const LTE_OPER: AXPFilterOperator;
+export declare const CONTAINS_OPER: AXPFilterOperator;
+export declare const NOT_CONTAINS_OPER: AXPFilterOperator;
+export declare const STARTS_WITH_OPER: AXPFilterOperator;
+export declare const ENDS_WITH_OPER: AXPFilterOperator;
+export declare const IS_EMPTY_OPER: AXPFilterOperator;
+export declare const IS_NOT_EMPTY_OPER: AXPFilterOperator;
+export declare const BETWEEN_OPER: AXPFilterOperator;
+export declare const STRING_OPERATORS: AXPFilterOperator[];
+export declare const NUMBER_OPERATORS: AXPFilterOperator[];
+export declare const BOOLEAN_OPERATORS: AXPFilterOperator[];
+export declare const DATE_OPERATORS: AXPFilterOperator[];

package/schema/lib/schema-registery.service.d.ts

@@ -0,0 +1,20 @@
+import { AXPSchemaConfig } from './schema';
+import * as i0 from "@angular/core";
+type DeepPartial<Thing> = Thing extends Function ? Thing : Thing extends Array<infer InferredArrayMember> ? DeepPartialArray<InferredArrayMember> : Thing extends object ? DeepPartialObject<Thing> : Thing | undefined;
+interface DeepPartialArray<Thing> extends Array<DeepPartial<Thing>> {
+}
+type DeepPartialObject<Thing> = {
+    [Key in keyof Thing]?: DeepPartial<Thing[Key]>;
+};
+type AXPSchemaOverride = Omit<DeepPartialObject<AXPSchemaConfig>, 'name'> & {
+    name: string;
+};
+export declare class AXPSchemaRegistryService {
+    private types;
+    register(schema: AXPSchemaConfig): void;
+    extend(parentName: string, schema: AXPSchemaOverride): void;
+    resolve(name: string): AXPSchemaConfig | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPSchemaRegistryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPSchemaRegistryService>;
+}
+export {};

package/schema/lib/schema.d.ts

@@ -0,0 +1,21 @@
+import { AXPComponentLoader } from './component-loader';
+import { AXPDisplayFormat } from './formats';
+import { AXPFilterOperator } from './operators';
+export type AXPValidationRule = {
+    rule: string;
+    message?: string;
+    options?: any;
+};
+export type AXPValidationRules = AXPValidationRule[];
+export interface AXPSchemaConfig {
+    name: string;
+    dataType: string;
+    component: AXPComponentLoader;
+    formats?: AXPDisplayFormat;
+    validationRules?: AXPValidationRules;
+    filterOptions: {
+        disabled?: boolean;
+        operators: AXPFilterOperator[];
+        default: AXPFilterOperator;
+    };
+}

package/schema/lib/schema.module.d.ts

@@ -0,0 +1,12 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./widget/widget-renderer";
+import * as i2 from "./widget/widget-column-renderer";
+import * as i3 from "./widget/widget-filter-renderer";
+import * as i4 from "@angular/cdk/portal";
+import * as i5 from "@acorex/components/skeleton";
+import * as i6 from "@angular/common";
+export declare class AXPSchemaModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPSchemaModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AXPSchemaModule, [typeof i1.AXPWidgetRendererComponent, typeof i2.AXPWidgetColumnRendererComponent, typeof i3.AXPWidgetFilterRendererComponent], [typeof i4.PortalModule, typeof i5.AXSkeletonModule, typeof i6.CommonModule], [typeof i1.AXPWidgetRendererComponent, typeof i3.AXPWidgetFilterRendererComponent, typeof i2.AXPWidgetColumnRendererComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AXPSchemaModule>;
+}

package/schema/lib/widget/widget-base.d.ts

@@ -0,0 +1,43 @@
+import { AXFormatService } from '@acorex/core/format';
+import { ChangeDetectorRef, EventEmitter } from '@angular/core';
+import { AXPDisplayFormat } from '../formats';
+import { AXPSchemaConfig, AXPValidationRules } from '../schema';
+import { AXPWidgetProperty } from './widget-token';
+import * as i0 from "@angular/core";
+export declare abstract class AXPWidgetBase<T = any> {
+    protected cdr: ChangeDetectorRef;
+    protected token: import("./widget-token").AXPWidgetTokenType;
+    protected formatService: AXFormatService;
+    markForCheck: () => void;
+    protected get schema(): AXPSchemaConfig;
+    protected get prop(): AXPWidgetProperty;
+    protected get formats(): AXPDisplayFormat;
+    private _context;
+    get context(): T;
+    set context(v: T);
+    protected render(): void;
+    protected setOption(name: string, value: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWidgetBase<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPWidgetBase<any>>;
+}
+export declare abstract class AXPWidgetEditBase<T = any> extends AXPWidgetBase<T> {
+    valueChange: EventEmitter<T>;
+    private _value;
+    get value(): T;
+    set value(v: T);
+    protected get validations(): AXPValidationRules;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWidgetEditBase<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPWidgetEditBase<any>>;
+}
+export declare abstract class AXPWidgetFilterBase<T = any> extends AXPWidgetBase<T> {
+    operatorChange: EventEmitter<string>;
+    private _operator;
+    get operator(): string;
+    set operator(op: string);
+    valueChange: EventEmitter<T>;
+    private _value;
+    get value(): T;
+    set value(v: T);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWidgetFilterBase<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPWidgetFilterBase<any>>;
+}

package/schema/lib/widget/widget-column-renderer.d.ts

@@ -0,0 +1,27 @@
+import { AXDataTableColumnComponent } from '@acorex/components/data-table';
+import { Injector, TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class AXPWidgetColumnRendererComponent extends AXDataTableColumnComponent {
+    private widgetRegistery;
+    mergedOptions: any;
+    private _template;
+    get template(): TemplateRef<unknown>;
+    get loadingEnabled(): boolean;
+    get name(): string;
+    options?: {
+        [key: string]: any;
+    };
+    dataField: string;
+    displayFormat: string | undefined;
+    private _schemaName;
+    get schemaName(): string;
+    set schemaName(v: string);
+    private injector;
+    private cdr;
+    protected widgetInjector: Injector;
+    protected component: any;
+    ngOnInit(): Promise<void>;
+    getInputs(data: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWidgetColumnRendererComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXPWidgetColumnRendererComponent, "axp-widget-column-renderer", never, { "width": { "alias": "width"; "required": false; }; "caption": { "alias": "caption"; "required": false; }; "headerTemplate": { "alias": "headerTemplate"; "required": false; }; "allowSorting": { "alias": "allowSorting"; "required": false; }; "fixed": { "alias": "fixed"; "required": false; }; "options": { "alias": "options"; "required": false; }; "dataField": { "alias": "dataField"; "required": false; }; "displayFormat": { "alias": "displayFormat"; "required": false; }; "schemaName": { "alias": "schema"; "required": false; }; }, {}, never, never, false, never>;
+}

package/schema/lib/widget/widget-filter-renderer.d.ts

@@ -0,0 +1,30 @@
+import { CdkPortalOutletAttachedRef, ComponentPortal } from '@angular/cdk/portal';
+import { EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class AXPWidgetFilterRendererComponent {
+    private widgetRegistery;
+    protected isLoading: boolean;
+    valueChange: EventEmitter<any>;
+    operatorChange: EventEmitter<any>;
+    private _value;
+    get value(): any;
+    set value(v: any);
+    private _operator;
+    get operator(): any;
+    set operator(op: any);
+    prop: any;
+    private _schemaName;
+    get schemaName(): string;
+    set schemaName(v: string);
+    private injector;
+    private cdr;
+    private instance;
+    private options;
+    protected portal: ComponentPortal<any>;
+    private render;
+    private updateValue;
+    private updateOperator;
+    protected handleAttached(portalOutletRef: CdkPortalOutletAttachedRef): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWidgetFilterRendererComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXPWidgetFilterRendererComponent, "axp-widget-filter-renderer", never, { "value": { "alias": "value"; "required": false; }; "operator": { "alias": "operator"; "required": false; }; "prop": { "alias": "prop"; "required": false; }; "schemaName": { "alias": "schema"; "required": false; }; }, { "valueChange": "valueChange"; "operatorChange": "operatorChange"; }, never, never, false, never>;
+}

package/schema/lib/widget/widget-renderer.d.ts

@@ -0,0 +1,26 @@
+import { CdkPortalOutletAttachedRef, ComponentPortal } from '@angular/cdk/portal';
+import * as i0 from "@angular/core";
+export declare class AXPWidgetRendererComponent {
+    private widgetRegistery;
+    private subscriber;
+    private _context;
+    get context(): any;
+    set context(v: any);
+    prop: any;
+    mode: 'view' | 'edit';
+    protected isLoading: boolean;
+    private _schemaName;
+    get schemaName(): string;
+    set schemaName(v: string);
+    private injector;
+    private cdr;
+    private instance;
+    private options;
+    protected portal: ComponentPortal<any>;
+    private render;
+    private updateValue;
+    private updateProps;
+    protected handleAttached(portalOutletRef: CdkPortalOutletAttachedRef): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWidgetRendererComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AXPWidgetRendererComponent, "axp-widget-renderer", never, { "context": { "alias": "context"; "required": false; }; "prop": { "alias": "prop"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "schemaName": { "alias": "schema"; "required": false; }; }, {}, never, never, false, never>;
+}

package/schema/lib/widget/widget-token.d.ts

@@ -0,0 +1,15 @@
+import { InjectionToken } from '@angular/core';
+import { AXPDisplayFormat } from '../formats';
+import { AXPSchemaConfig, AXPValidationRules } from '../schema';
+export interface AXPWidgetProperty {
+    name: string;
+    description?: string;
+    formats: AXPDisplayFormat;
+    validationRules?: AXPValidationRules;
+    canEdit: boolean;
+}
+export interface AXPWidgetTokenType {
+    schema: AXPSchemaConfig;
+    prop: AXPWidgetProperty;
+}
+export declare const AXP_WIDGET_TOKEN: InjectionToken<AXPWidgetTokenType>;

package/workflow/README.md

@@ -0,0 +1,4 @@
+# @acorex/platform/workflow
+
+Secondary entry point of `@acorex/platform`. It can be used by importing from `@acorex/platform/workflow`.
+            

package/workflow/index.d.ts

@@ -0,0 +1,6 @@
+export * from './lib/errors.types';
+export * from './lib/workflow-event-dispatcher.service';
+export * from './lib/workflow-registery.service';
+export * from './lib/workflow.module';
+export * from './lib/workflow.service';
+export * from './lib/workflow.types';

package/workflow/lib/errors.types.d.ts

@@ -0,0 +1,4 @@
+export declare class AXPWorkflowError extends Error {
+    inner: Error | null;
+    constructor(message: string, inner?: Error | null);
+}

package/workflow/lib/workflow-event-dispatcher.service.d.ts

@@ -0,0 +1,10 @@
+import { Observable } from 'rxjs';
+import { AXPWorkflowEvent } from './workflow.types';
+import * as i0 from "@angular/core";
+export declare class AXPWorkflowEventService {
+    private eventSubject;
+    dispatch(event: AXPWorkflowEvent): void;
+    get events$(): Observable<AXPWorkflowEvent>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWorkflowEventService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPWorkflowEventService>;
+}

package/workflow/lib/workflow-registery.service.d.ts

@@ -0,0 +1,17 @@
+import { Type } from '@angular/core';
+import { AXPWorkflow, AXPWorkflowAction, AXPWorkflowFunction } from './workflow.types';
+import * as i0 from "@angular/core";
+export declare class AXPWorkflowRegistryService {
+    private functionsMap;
+    private actionsMap;
+    private workflowsMap;
+    registerWorkflow(name: string, workflow: AXPWorkflow): void;
+    getWorkflow(name: string): AXPWorkflow | undefined;
+    registerAction(name: string, action: Type<AXPWorkflowAction>): void;
+    getAction(name: string): Type<AXPWorkflowAction> | undefined;
+    registerFunction(name: string, func: Type<AXPWorkflowFunction>): void;
+    getFunction(name: string): Type<AXPWorkflowFunction> | undefined;
+    getFunctionNames(): string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWorkflowRegistryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPWorkflowRegistryService>;
+}

package/workflow/lib/workflow.module.d.ts

@@ -0,0 +1,25 @@
+import { ModuleWithProviders, Type } from "@angular/core";
+import { AXPWorkflow, AXPWorkflowAction, AXPWorkflowFunction } from "./workflow.types";
+import * as i0 from "@angular/core";
+export interface AXPWorkflowModuleConfigs {
+    functions?: {
+        [name: string]: Type<AXPWorkflowFunction>;
+    };
+    actions?: {
+        [name: string]: Type<AXPWorkflowAction>;
+    };
+    workflows?: {
+        [name: string]: AXPWorkflow;
+    };
+}
+export declare class AXPWorkflowModule {
+    static forRoot(config?: AXPWorkflowModuleConfigs): ModuleWithProviders<AXPWorkflowModule>;
+    static forChild(config?: AXPWorkflowModuleConfigs): ModuleWithProviders<AXPWorkflowModule>;
+    /**
+     * @ignore
+     */
+    constructor(instances: any[]);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWorkflowModule, [{ optional: true; }]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AXPWorkflowModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AXPWorkflowModule>;
+}

package/workflow/lib/workflow.service.d.ts

@@ -0,0 +1,23 @@
+import { Injector } from '@angular/core';
+import { Observable } from 'rxjs';
+import { AXPWorkflowRegistryService } from './workflow-registery.service';
+import { AXPWorkflow, AXPWorkflowEvent } from './workflow.types';
+import * as i0 from "@angular/core";
+export declare class AXPWorkflowService {
+    private registryService;
+    private injector;
+    private eventService;
+    get events$(): Observable<AXPWorkflowEvent>;
+    constructor(registryService: AXPWorkflowRegistryService, injector: Injector);
+    execute(workflow: AXPWorkflow | string, initialContext?: any): Promise<void>;
+    private getActionInstance;
+    private getWorkflowInstance;
+    private determineNextStep;
+    private evaluateCondition;
+    private evaluateSingleCondition;
+    private evaluateExpression;
+    private createFunctionScope;
+    private getFunctionInstance;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWorkflowService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPWorkflowService>;
+}

package/workflow/lib/workflow.types.d.ts

@@ -0,0 +1,61 @@
+import * as i0 from "@angular/core";
+export interface AXPWorkflow {
+    steps: {
+        [stepName: string]: AXPWorkflowStep;
+    };
+    startStepId: string;
+}
+export declare class AXPWorkflowContext {
+    private variables;
+    private stepOutputs;
+    setVariable(key: string, value: any): void;
+    getVariable(key: string): any;
+    setOutput(stepId: string, output: any): void;
+    getOutput(stepId: string): any;
+}
+export type AXPWorkflowActionInput = any;
+export type AXPWorkflowConditionType = 'AND' | 'OR' | 'SINGLE';
+export interface AXPWorkflowCondition {
+    type: AXPWorkflowConditionType;
+    conditions?: AXPWorkflowCondition[];
+    expression?: string;
+}
+export interface AXPWorkflowNextStep {
+    conditions: AXPWorkflowCondition[];
+    nextStepId: string;
+}
+export interface AXPWorkflowStep {
+    id: string;
+    action: AXPWorkflowAction | string;
+    input?: AXPWorkflowActionInput;
+    nextSteps?: AXPWorkflowNextStep[];
+    conditions?: AXPWorkflowCondition[];
+}
+export declare abstract class AXPWorkflowAction {
+    private eventService;
+    protected dispatch(event: AXPWorkflowEvent): void;
+    abstract execute(context: AXPWorkflowContext): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWorkflowAction, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPWorkflowAction>;
+}
+export declare abstract class AXPWorkflowFunction {
+    abstract execute(...args: any[]): Promise<any> | any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPWorkflowFunction, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPWorkflowFunction>;
+}
+export interface AXPWorkflowEvent {
+    type: string;
+    payload?: any;
+}
+export declare function createWorkFlowEvent<T>(type: string): {
+    (payload: T): {
+        type: string;
+        payload: T;
+    };
+    type: string;
+};
+export declare function ofType<T extends {
+    type: string;
+}>(...allowedTypes: Array<{
+    type: string;
+}>): import("rxjs").MonoTypeOperatorFunction<T>;