@abp/ng.components 7.4.1 → 8.0.0-rc.1

package/extensible/lib/directives/prop-data.directive.d.ts

@@ -0,0 +1,19 @@
+import { Injector, OnChanges, OnDestroy, TemplateRef, ViewContainerRef } from '@angular/core';
+import { PropData, PropList } from '../models/props';
+import * as i0 from "@angular/core";
+export declare class PropDataDirective<L extends PropList<any>> extends PropData<InferredData<L>> implements OnChanges, OnDestroy {
+    private tempRef;
+    private vcRef;
+    propList?: L;
+    record: InferredData<L>['record'];
+    index?: number;
+    readonly getInjected: InferredData<L>['getInjected'];
+    constructor(tempRef: TemplateRef<any>, vcRef: ViewContainerRef, injector: Injector);
+    ngOnChanges(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PropDataDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PropDataDirective<any>, "[abpPropData]", ["abpPropData"], { "propList": { "alias": "abpPropDataFromList"; "required": false; }; "record": { "alias": "abpPropDataWithRecord"; "required": false; }; "index": { "alias": "abpPropDataAtIndex"; "required": false; }; }, {}, never, never, true, never>;
+}
+type InferredData<L> = PropData<InferredRecord<L>>;
+type InferredRecord<L> = L extends PropList<infer R> ? R : never;
+export {};

package/extensible/lib/enums/components.d.ts

@@ -0,0 +1,3 @@
+export declare const enum eThemeSharedComponents {
+    PasswordComponent = "ThemeShared.Extensions.PasswordComponent"
+}

package/extensible/lib/enums/props.enum.d.ts

@@ -0,0 +1,16 @@
+export declare const enum ePropType {
+    Boolean = "boolean",
+    Date = "date",
+    DateTime = "datetime",
+    Email = "email",
+    Enum = "enum",
+    Hidden = "hidden",
+    MultiSelect = "multiselect",
+    Number = "number",
+    Password = "password",
+    PasswordInputGroup = "passwordinputgroup",
+    String = "string",
+    Text = "text",
+    Time = "time",
+    Typeahead = "typeahead"
+}

package/extensible/lib/extensible.module.d.ts

@@ -0,0 +1,18 @@
+import * as i0 from "@angular/core";
+import * as i1 from "@abp/ng.core";
+import * as i2 from "@abp/ng.theme.shared";
+import * as i3 from "@ngx-validate/core";
+import * as i4 from "@ng-bootstrap/ng-bootstrap";
+import * as i5 from "./components/date-time-picker/extensible-date-time-picker.component";
+import * as i6 from "./components/extensible-form/extensible-form-prop.component";
+import * as i7 from "./components/grid-actions/grid-actions.component";
+import * as i8 from "./directives/prop-data.directive";
+import * as i9 from "./components/page-toolbar/page-toolbar.component";
+import * as i10 from "./pipes/create-injector.pipe";
+import * as i11 from "./components/extensible-form/extensible-form.component";
+import * as i12 from "./components/extensible-table/extensible-table.component";
+export declare class ExtensibleModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExtensibleModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ExtensibleModule, never, [typeof i1.CoreModule, typeof i2.ThemeSharedModule, typeof i3.NgxValidateCoreModule, typeof i4.NgbDatepickerModule, typeof i4.NgbDropdownModule, typeof i4.NgbTimepickerModule, typeof i4.NgbTypeaheadModule, typeof i4.NgbTooltipModule, typeof i2.DisabledDirective, typeof i5.ExtensibleDateTimePickerComponent, typeof i6.ExtensibleFormPropComponent, typeof i7.GridActionsComponent, typeof i8.PropDataDirective, typeof i9.PageToolbarComponent, typeof i10.CreateInjectorPipe, typeof i11.ExtensibleFormComponent, typeof i12.ExtensibleTableComponent], [typeof i2.DisabledDirective, typeof i5.ExtensibleDateTimePickerComponent, typeof i6.ExtensibleFormPropComponent, typeof i7.GridActionsComponent, typeof i8.PropDataDirective, typeof i9.PageToolbarComponent, typeof i10.CreateInjectorPipe, typeof i11.ExtensibleFormComponent, typeof i12.ExtensibleTableComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ExtensibleModule>;
+}

package/extensible/lib/models/actions.d.ts

@@ -0,0 +1,38 @@
+import { LinkedList } from '@abp/utils';
+import { InjectFlags, InjectionToken, InjectOptions, Type } from '@angular/core';
+import { O } from 'ts-toolbelt';
+export declare abstract class ActionList<R = any, A = Action<R>> extends LinkedList<A> {
+}
+export declare abstract class ActionData<R = any> {
+    abstract getInjected: <T>(token: Type<T> | InjectionToken<T>, notFoundValue?: T, flags?: InjectOptions | InjectFlags) => T;
+    index?: number;
+    abstract record: R;
+    get data(): ReadonlyActionData<R>;
+}
+export type ReadonlyActionData<R = any> = O.Readonly<Omit<ActionData<R>, 'data'>>;
+export declare abstract class Action<R = any> {
+    readonly permission: string;
+    readonly visible: ActionPredicate<R>;
+    readonly action: ActionCallback<R>;
+    readonly btnClass?: string;
+    readonly btnStyle?: string;
+    constructor(permission: string, visible?: ActionPredicate<R>, action?: ActionCallback<R>, btnClass?: string, btnStyle?: string);
+}
+export type ActionCallback<T, R = any> = (data: Omit<ActionData<T>, 'data'>) => R;
+export type ActionPredicate<T> = (data?: Omit<ActionData<T>, 'data'>) => boolean;
+export declare abstract class ActionsFactory<C extends Actions<any>> {
+    protected abstract _ctor: Type<C>;
+    private contributorCallbacks;
+    get(name: string): C;
+}
+export declare abstract class Actions<L extends ActionList<any, InferredAction<L>>> {
+    private readonly callbackList;
+    protected abstract _ctor: Type<L>;
+    get actions(): L;
+    constructor(callbackList: ActionContributorCallback<L>[]);
+    addContributor(contributeCallback: ActionContributorCallback<L>): void;
+    clearContributors(): void;
+}
+export type ActionContributorCallbacks<L extends ActionList<any, InferredAction<L>>> = Record<string, ActionContributorCallback<L>[]>;
+export type ActionContributorCallback<L extends ActionList<any, InferredAction<L>>> = (actionList: L) => any;
+export type InferredAction<T> = T extends ActionList<any, infer U> ? U : T;

package/extensible/lib/models/entity-actions.d.ts

@@ -0,0 +1,24 @@
+import { Type } from '@angular/core';
+import { O } from 'ts-toolbelt';
+import { Action, ActionContributorCallback, ActionContributorCallbacks, ActionList, Actions, ActionsFactory } from './actions';
+export declare class EntityActionList<R = any> extends ActionList<R, EntityAction<R>> {
+}
+export declare class EntityActions<R = any> extends Actions<EntityActionList<R>> {
+    protected _ctor: Type<EntityActionList<R>>;
+}
+export declare class EntityActionsFactory<R = any> extends ActionsFactory<EntityActions<R>> {
+    protected _ctor: Type<EntityActions<R>>;
+}
+export declare class EntityAction<R = any> extends Action<R> {
+    readonly text: string;
+    readonly icon: string;
+    readonly btnClass?: string;
+    readonly btnStyle?: string;
+    constructor(options: EntityActionOptions<R>);
+    static create<R = any>(options: EntityActionOptions<R>): EntityAction<R>;
+    static createMany<R = any>(arrayOfOptions: EntityActionOptions<R>[]): EntityAction<R>[];
+}
+export type EntityActionOptions<R = any> = O.Optional<O.Writable<EntityAction<R>>, 'permission' | 'visible' | 'icon'>;
+export type EntityActionDefaults<R = any> = Record<string, EntityAction<R>[]>;
+export type EntityActionContributorCallback<R = any> = ActionContributorCallback<EntityActionList<R>>;
+export type EntityActionContributorCallbacks<R = any> = ActionContributorCallbacks<EntityActionList<R>>;

package/extensible/lib/models/entity-props.d.ts

@@ -0,0 +1,33 @@
+import { ABP } from '@abp/ng.core';
+import { InjectFlags, InjectOptions, InjectionToken, Type } from '@angular/core';
+import { Observable } from 'rxjs';
+import { O } from 'ts-toolbelt';
+import { ActionCallback } from './actions';
+import { Prop, PropCallback, PropContributorCallback, PropContributorCallbacks, PropList, Props, PropsFactory } from './props';
+export declare class EntityPropList<R = any> extends PropList<R, EntityProp<R>> {
+}
+export declare class EntityProps<R = any> extends Props<EntityPropList<R>> {
+    protected _ctor: Type<EntityPropList<R>>;
+}
+export declare class EntityPropsFactory<R = any> extends PropsFactory<EntityProps<R>> {
+    protected _ctor: Type<EntityProps<R>>;
+}
+export declare class EntityProp<R = any> extends Prop<R> {
+    readonly columnWidth: number | undefined;
+    readonly sortable: boolean;
+    readonly valueResolver: PropCallback<R, Observable<any>>;
+    readonly action?: ActionCallback<R>;
+    readonly component?: Type<any>;
+    readonly enumList?: Array<ABP.Option<any>>;
+    readonly tooltip?: string;
+    readonly columnVisible: ColumnPredicate;
+    constructor(options: EntityPropOptions<R>);
+    static create<R = any>(options: EntityPropOptions<R>): EntityProp<R>;
+    static createMany<R = any>(arrayOfOptions: EntityPropOptions<R>[]): EntityProp<R>[];
+}
+export type EntityPropOptions<R = any> = O.Optional<O.Writable<EntityProp<R>>, 'permission' | 'visible' | 'columnVisible' | 'displayName' | 'isExtra' | 'columnWidth' | 'sortable' | 'valueResolver' | 'action' | 'component' | 'enumList'>;
+export type EntityPropDefaults<R = any> = Record<string, EntityProp<R>[]>;
+export type EntityPropContributorCallback<R = any> = PropContributorCallback<EntityPropList<R>>;
+export type EntityPropContributorCallbacks<R = any> = PropContributorCallbacks<EntityPropList<R>>;
+export type ColumnPredicate = (getInjected: GetInjected, auxData?: any) => boolean;
+export type GetInjected = <T>(token: Type<T> | InjectionToken<T>, notFoundValue?: T, options?: InjectOptions | InjectFlags) => T;

package/extensible/lib/models/form-props.d.ts

@@ -0,0 +1,59 @@
+import { ABP } from '@abp/ng.core';
+import { Injector, Type } from '@angular/core';
+import { AsyncValidatorFn, ValidatorFn } from '@angular/forms';
+import { Observable } from 'rxjs';
+import { O } from 'ts-toolbelt';
+import { Prop, PropCallback, PropContributorCallback, PropContributorCallbacks, PropData, PropDisplayTextResolver, PropList, PropPredicate, Props, PropsFactory } from './props';
+export declare class FormPropList<R = any> extends PropList<R, FormProp<R>> {
+}
+export declare class FormProps<R = any> extends Props<PropList<R, FormProp<R>>> {
+    protected _ctor: Type<FormPropList<R>>;
+}
+export interface FormPropGroup {
+    name: string;
+    className?: string;
+}
+export declare class GroupedFormPropList<R = any> {
+    readonly items: GroupedFormPropItem[];
+    addItem(item: FormProp<R>): void;
+}
+export interface GroupedFormPropItem {
+    group?: FormPropGroup;
+    formPropList: FormPropList;
+}
+export declare class CreateFormPropsFactory<R = any> extends PropsFactory<FormProps<R>> {
+    protected _ctor: Type<FormProps<R>>;
+}
+export declare class EditFormPropsFactory<R = any> extends PropsFactory<FormProps<R>> {
+    protected _ctor: Type<FormProps<R>>;
+}
+export declare class FormProp<R = any> extends Prop<R> {
+    readonly validators: PropCallback<R, ValidatorFn[]>;
+    readonly asyncValidators: PropCallback<R, AsyncValidatorFn[]>;
+    readonly disabled: PropPredicate<R>;
+    readonly readonly: PropPredicate<R>;
+    readonly autocomplete: string;
+    readonly defaultValue: boolean | number | string | Date;
+    readonly options: PropCallback<R, Observable<ABP.Option<any>[]>> | undefined;
+    readonly id: string | undefined;
+    readonly template?: Type<any>;
+    readonly className?: string;
+    readonly group?: FormPropGroup | undefined;
+    readonly displayTextResolver?: PropDisplayTextResolver<R>;
+    readonly formText?: string;
+    constructor(options: FormPropOptions<R>);
+    static create<R = any>(options: FormPropOptions<R>): FormProp<R>;
+    static createMany<R = any>(arrayOfOptions: FormPropOptions<R>[]): FormProp<R>[];
+}
+export declare class FormPropData<R = any> extends PropData<R> {
+    readonly record: R;
+    getInjected: PropData<R>['getInjected'];
+    constructor(injector: Injector, record: R);
+}
+export type FormPropOptions<R = any> = O.Optional<O.Writable<FormProp<R>>, 'permission' | 'visible' | 'displayName' | 'isExtra' | 'validators' | 'asyncValidators' | 'disabled' | 'readonly' | 'autocomplete' | 'defaultValue' | 'options' | 'id' | 'displayTextResolver' | 'formText'>;
+export type CreateFormPropDefaults<R = any> = Record<string, FormProp<R>[]>;
+export type CreateFormPropContributorCallback<R = any> = PropContributorCallback<FormPropList<R>>;
+export type CreateFormPropContributorCallbacks<R = any> = PropContributorCallbacks<FormPropList<R>>;
+export type EditFormPropDefaults<R = any> = Record<string, FormProp<R>[]>;
+export type EditFormPropContributorCallback<R = any> = PropContributorCallback<FormPropList<R>>;
+export type EditFormPropContributorCallbacks<R = any> = PropContributorCallbacks<FormPropList<R>>;

package/extensible/lib/models/internal/object-extensions.d.ts

@@ -0,0 +1,86 @@
+import { ePropType } from '../../enums/props.enum';
+import { EntityPropList } from '../entity-props';
+import { FormPropList } from '../form-props';
+import { PropContributorCallbacks } from '../props';
+export type DisplayNameGeneratorFn = (displayName: LocalizableStringDto, fallback: LocalizableStringDto) => string | undefined;
+export type EntityExtensions = Record<string, EntityExtensionDto>;
+export interface EntityExtensionDto {
+    properties: EntityExtensionProperties;
+    configuration: Record<string, object>;
+}
+export type EntityExtensionProperties = Record<string, ExtensionPropertyDto>;
+export interface ExtensionEnumDto {
+    fields: ExtensionEnumFieldDto[];
+    localizationResource?: string;
+    transformed?: any;
+}
+export interface ExtensionEnumFieldDto {
+    name?: string;
+    value: any;
+}
+export interface ExtensionPropertyApiCreateDto {
+    isAvailable: boolean;
+}
+export interface ExtensionPropertyApiDto {
+    onGet: ExtensionPropertyApiGetDto;
+    onCreate: ExtensionPropertyApiCreateDto;
+    onUpdate: ExtensionPropertyApiUpdateDto;
+}
+export interface ExtensionPropertyApiGetDto {
+    isAvailable: boolean;
+}
+export interface ExtensionPropertyApiUpdateDto {
+    isAvailable: boolean;
+}
+export interface ExtensionPropertyAttributeDto {
+    typeSimple?: string;
+    config: Record<string, any>;
+}
+export interface ExtensionPropertyDto {
+    type?: string;
+    typeSimple?: ePropType;
+    displayName: LocalizableStringDto;
+    api: ExtensionPropertyApiDto;
+    ui: ExtensionPropertyUiDto;
+    attributes: ExtensionPropertyAttributeDto[];
+    configuration: Record<string, any>;
+    defaultValue: any;
+    formText?: string;
+}
+export interface ExtensionPropertyUiDto {
+    onTable: ExtensionPropertyUiTableDto;
+    onCreateForm: ExtensionPropertyUiFormDto;
+    onEditForm: ExtensionPropertyUiFormDto;
+    lookup?: ExtensionPropertyUiLookupDto;
+}
+export interface ExtensionPropertyUiFormDto {
+    isVisible: boolean;
+}
+export interface ExtensionPropertyUiLookupDto {
+    url?: string;
+    resultListPropertyName?: string;
+    displayPropertyName?: string;
+    valuePropertyName?: string;
+    filterParamName?: string;
+}
+export interface ExtensionPropertyUiTableDto {
+    isSortable?: boolean;
+    isVisible: boolean;
+}
+export interface LocalizableStringDto {
+    name?: string;
+    resource?: string;
+}
+export interface ModuleExtensionDto {
+    entities: Record<string, EntityExtensionDto>;
+    configuration: Record<string, object>;
+}
+export interface ObjectExtensionsDto {
+    modules: Record<string, ModuleExtensionDto>;
+    enums: Record<string, ExtensionEnumDto>;
+}
+export interface PropContributors<T = any> {
+    prop: PropContributorCallbacks<EntityPropList<T>>;
+    createForm: PropContributorCallbacks<FormPropList<T>>;
+    editForm: PropContributorCallbacks<FormPropList<T>>;
+}

package/extensible/lib/models/object-extensions.d.ts

@@ -0,0 +1,2 @@
+import * as ObjectExtensions from './internal/object-extensions';
+export { ObjectExtensions };

package/extensible/lib/models/props.d.ts

@@ -0,0 +1,45 @@
+import { LinkedList } from '@abp/utils';
+import { InjectFlags, InjectionToken, InjectOptions, Type } from '@angular/core';
+import { O } from 'ts-toolbelt';
+import { ePropType } from '../enums/props.enum';
+export declare abstract class PropList<R = any, A = Prop<R>> extends LinkedList<A> {
+}
+export declare abstract class PropData<R = any> {
+    abstract getInjected: <T>(token: Type<T> | InjectionToken<T>, notFoundValue?: T, options?: InjectOptions | InjectFlags) => T;
+    index?: number;
+    abstract record: R;
+    get data(): ReadonlyPropData<R>;
+}
+export type ReadonlyPropData<R = any> = O.Readonly<Omit<PropData<R>, 'data'>>;
+export declare abstract class Prop<R = any> {
+    readonly type: ePropType;
+    readonly name: string;
+    readonly displayName: string;
+    readonly permission: string;
+    readonly visible: PropPredicate<R>;
+    readonly isExtra: boolean;
+    readonly template?: Type<any>;
+    readonly className?: string;
+    readonly formText?: string;
+    readonly displayTextResolver?: PropDisplayTextResolver<R>;
+    constructor(type: ePropType, name: string, displayName: string, permission: string, visible?: PropPredicate<R>, isExtra?: boolean, template?: Type<any>, className?: string, formText?: string, displayTextResolver?: PropDisplayTextResolver<R>);
+}
+export type PropCallback<T, R = any> = (data: Omit<PropData<T>, 'data'>, auxData?: any) => R;
+export type PropPredicate<T> = (data?: Omit<PropData<T>, 'data'>, auxData?: any) => boolean;
+export type PropDisplayTextResolver<T> = (data?: Omit<PropData<T>, 'data'>) => string;
+export declare abstract class PropsFactory<C extends Props<any>> {
+    protected abstract _ctor: Type<C>;
+    private contributorCallbacks;
+    get(name: string): C;
+}
+export declare abstract class Props<L extends PropList<any, InferredProp<L>>> {
+    private readonly callbackList;
+    protected abstract _ctor: Type<L>;
+    get props(): L;
+    constructor(callbackList: PropContributorCallback<L>[]);
+    addContributor(contributeCallback: PropContributorCallback<L>): void;
+    clearContributors(): void;
+}
+export type PropContributorCallbacks<L extends PropList<any, InferredProp<L>>> = Record<string, PropContributorCallback<L>[]>;
+export type PropContributorCallback<L extends PropList<any, InferredProp<L>>> = (propList: L) => any;
+export type InferredProp<T> = T extends PropList<any, infer U> ? U : T;

package/extensible/lib/models/toolbar-actions.d.ts

@@ -0,0 +1,38 @@
+import { Injector, Type } from '@angular/core';
+import { O } from 'ts-toolbelt';
+import { Action, ActionContributorCallback, ActionContributorCallbacks, ActionData, ActionList, Actions, ActionsFactory, ReadonlyActionData } from './actions';
+export declare class ToolbarActionList<R = any> extends ActionList<R, ToolbarActionDefault<R>> {
+}
+export declare class ToolbarActions<R = any> extends Actions<ToolbarActionList<R>> {
+    protected _ctor: Type<ToolbarActionList<R>>;
+}
+export declare class ToolbarActionsFactory<R = any> extends ActionsFactory<ToolbarActions<R>> {
+    protected _ctor: Type<ToolbarActions<R>>;
+}
+export declare class ToolbarAction<R = any> extends Action<R> {
+    readonly text: string;
+    readonly icon: string;
+    readonly btnClass?: string;
+    constructor(options: ToolbarActionOptions<R>);
+    static create<R = any>(options: ToolbarActionOptions<R>): ToolbarAction<R>;
+    static createMany<R = any>(arrayOfOptions: ToolbarActionOptions<R>[]): ToolbarAction<R>[];
+}
+export declare class ToolbarComponent<R = any> extends Action<R> {
+    readonly component: Type<any>;
+    constructor(options: ToolbarComponentOptions<R>);
+    static create<R = any>(options: ToolbarComponentOptions<R>): ToolbarComponent<R>;
+    static createMany<R = any>(arrayOfOptions: ToolbarComponentOptions<R>[]): ToolbarComponent<R>[];
+}
+export type ToolbarActionOptions<R = any> = O.Optional<O.Writable<ToolbarAction<R>>, 'permission' | 'visible' | 'icon' | 'btnClass'>;
+export type ToolbarComponentOptions<R = any> = O.Optional<O.Writable<ToolbarComponent<R>>, 'permission' | 'visible' | 'action'>;
+export type ToolbarActionDefault<R = any> = ToolbarAction<R> | ToolbarComponent<R>;
+export type ToolbarActionDefaults<R = any> = Record<string, Array<ToolbarActionDefault<R>>>;
+export type ToolbarActionContributorCallback<R = any> = ActionContributorCallback<ToolbarActionList<R>>;
+export type ToolbarActionContributorCallbacks<R = any> = ActionContributorCallbacks<ToolbarActionList<R>>;
+export type InferredData<L> = ActionData<InferredRecord<L>>;
+export type InferredRecord<L> = L extends ActionList<infer R> ? R : any;
+export interface HasCreateInjectorPipe<R> {
+    getData: () => ReadonlyActionData<R>;
+    injector: Injector;
+    getInjected: InferredData<ToolbarActionList<R>>['getInjected'];
+}

package/extensible/lib/pipes/create-injector.pipe.d.ts

@@ -0,0 +1,8 @@
+import { Injector, PipeTransform } from '@angular/core';
+import { HasCreateInjectorPipe, ToolbarComponent } from '../models/toolbar-actions';
+import * as i0 from "@angular/core";
+export declare class CreateInjectorPipe<R> implements PipeTransform {
+    transform(_: any, action: ToolbarComponent<R>, context: HasCreateInjectorPipe<R>): Injector;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CreateInjectorPipe<any>, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CreateInjectorPipe<any>, "createInjector", true>;
+}

package/extensible/lib/services/extensible-form-prop.service.d.ts

@@ -0,0 +1,13 @@
+import { ValidatorFn } from '@angular/forms';
+import { FormProp } from '../models/form-props';
+import * as i0 from "@angular/core";
+export declare class ExtensibleFormPropService {
+    #private;
+    meridian$: import("rxjs").Observable<boolean>;
+    isRequired(validator: ValidatorFn): boolean;
+    getComponent(prop: FormProp): "hidden" | "date" | "select" | "time" | "multiselect" | "passwordinputgroup" | "typeahead" | "template" | "checkbox" | "dateTime" | "textarea" | "input";
+    getType(prop: FormProp): "email" | "hidden" | "number" | "text" | "password" | "passwordinputgroup" | "checkbox";
+    calcAsterisks(validators: ValidatorFn[]): "" | "*";
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExtensibleFormPropService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ExtensibleFormPropService>;
+}

package/extensible/lib/services/extensions.service.d.ts

@@ -0,0 +1,14 @@
+import { EntityActionsFactory } from '../models/entity-actions';
+import { EntityPropsFactory } from '../models/entity-props';
+import { CreateFormPropsFactory, EditFormPropsFactory } from '../models/form-props';
+import { ToolbarActionsFactory } from '../models/toolbar-actions';
+import * as i0 from "@angular/core";
+export declare class ExtensionsService<R = any> {
+    readonly entityActions: EntityActionsFactory<R>;
+    readonly toolbarActions: ToolbarActionsFactory<R[]>;
+    readonly entityProps: EntityPropsFactory<R>;
+    readonly createFormProps: CreateFormPropsFactory<R>;
+    readonly editFormProps: EditFormPropsFactory<R>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExtensionsService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ExtensionsService<any>>;
+}

package/extensible/lib/tokens/extensible-form-view-provider.token.d.ts

@@ -0,0 +1,5 @@
+import { ControlContainer, FormGroupDirective } from "@angular/forms";
+export declare const EXTENSIBLE_FORM_VIEW_PROVIDER: {
+    provide: typeof ControlContainer;
+    useExisting: typeof FormGroupDirective;
+};

package/extensible/lib/tokens/extensions.token.d.ts

@@ -0,0 +1,20 @@
+import { InjectionToken } from '@angular/core';
+import { ActionCallback, ReadonlyActionData as ActionData } from '../models/actions';
+import { ExtensionsService } from '../services/extensions.service';
+import { Observable } from 'rxjs';
+import { ePropType } from '../enums/props.enum';
+import { FormProp } from '../models/form-props';
+export declare const EXTENSIONS_IDENTIFIER: InjectionToken<string>;
+export type ActionKeys = Extract<'entityActions' | 'toolbarActions', keyof ExtensionsService>;
+export declare const EXTENSIONS_ACTION_TYPE: InjectionToken<ActionKeys>;
+export declare const EXTENSIONS_ACTION_DATA: InjectionToken<ActionData>;
+export declare const EXTENSIONS_ACTION_CALLBACK: InjectionToken<ActionCallback<unknown>>;
+export declare const PROP_DATA_STREAM: InjectionToken<Observable<any>>;
+type EntityPropTypeClassMap = {
+    [key in ePropType]: string;
+};
+export type EntityPropTypeClass = Partial<EntityPropTypeClassMap>;
+export declare const ENTITY_PROP_TYPE_CLASSES: InjectionToken<Partial<EntityPropTypeClassMap>>;
+export declare const EXTENSIONS_FORM_PROP: InjectionToken<FormProp<any>>;
+export declare const EXTENSIONS_FORM_PROP_DATA: InjectionToken<unknown>;
+export {};

package/extensible/lib/utils/actions.util.d.ts

@@ -0,0 +1,7 @@
+import { ActionsFactory } from "../models/actions";
+import { EntityActionContributorCallbacks, EntityActionDefaults, EntityActionsFactory } from '../models/entity-actions';
+import { ToolbarActionContributorCallbacks, ToolbarActionDefaults, ToolbarActionsFactory } from '../models/toolbar-actions';
+export declare function mergeWithDefaultActions<F extends ActionsFactory<any>>(extension: F, defaultActions: InferredActionDefaults<F>, ...contributors: InferredActionContributorCallbacks<F>[]): void;
+type InferredActionDefaults<F> = F extends EntityActionsFactory<infer RE> ? EntityActionDefaults<RE> : F extends ToolbarActionsFactory<infer RT> ? ToolbarActionDefaults<RT> : never;
+type InferredActionContributorCallbacks<F> = F extends EntityActionsFactory<infer RE> ? EntityActionContributorCallbacks<RE> : F extends ToolbarActionsFactory<infer RT> ? ToolbarActionContributorCallbacks<RT> : never;
+export {};

package/extensible/lib/utils/enum.util.d.ts

@@ -0,0 +1,7 @@
+import { ABP, ExtensionEnumFieldDto } from '@abp/ng.core';
+import { Observable } from 'rxjs';
+import { ObjectExtensions } from '../models/object-extensions';
+import { PropCallback } from '../models/props';
+export declare function createEnum(members: ExtensionEnumFieldDto[]): any;
+export declare function createEnumValueResolver<T = any>(enumType: string, lookupEnum: ObjectExtensions.ExtensionEnumDto, propName: string): PropCallback<T, Observable<string>>;
+export declare function createEnumOptions<T = any>(enumType: string, lookupEnum: ObjectExtensions.ExtensionEnumDto): PropCallback<T, Observable<ABP.Option<any>[]>>;

package/extensible/lib/utils/factory.util.d.ts

@@ -0,0 +1 @@
+export declare function selfFactory(dependency?: any): any;

package/extensible/lib/utils/form-props.util.d.ts

@@ -0,0 +1,3 @@
+import { UntypedFormGroup } from '@angular/forms';
+import { PropData } from "../models/props";
+export declare function generateFormFromProps<R = any>(data: PropData<R>): UntypedFormGroup;

package/extensible/lib/utils/localization.util.d.ts

@@ -0,0 +1,3 @@
+import { ApplicationLocalizationConfigurationDto } from '@abp/ng.core';
+import { ObjectExtensions } from '../models/object-extensions';
+export declare function createDisplayNameLocalizationPipeKeyGenerator(localization: ApplicationLocalizationConfigurationDto): (displayName: ObjectExtensions.LocalizableStringDto, fallback: ObjectExtensions.LocalizableStringDto) => string;

package/extensible/lib/utils/props.util.d.ts

@@ -0,0 +1,9 @@
+import { Observable } from 'rxjs';
+import { EntityPropContributorCallbacks, EntityPropDefaults, EntityPropsFactory } from '../models/entity-props';
+import { CreateFormPropContributorCallbacks, CreateFormPropDefaults, CreateFormPropsFactory, EditFormPropContributorCallbacks, EditFormPropDefaults, EditFormPropsFactory } from '../models/form-props';
+import { PropCallback, PropsFactory } from '../models/props';
+export declare function createExtraPropertyValueResolver<T>(name: string): PropCallback<T, Observable<any>>;
+export declare function mergeWithDefaultProps<F extends PropsFactory<any>>(extension: F, defaultProps: InferredPropDefaults<F>, ...contributors: InferredPropContributorCallbacks<F>[]): void;
+type InferredPropDefaults<F> = F extends EntityPropsFactory<infer RE> ? EntityPropDefaults<RE> : F extends CreateFormPropsFactory<infer RCF> ? CreateFormPropDefaults<RCF> : F extends EditFormPropsFactory<infer REF> ? EditFormPropDefaults<REF> : never;
+type InferredPropContributorCallbacks<F> = F extends EntityPropsFactory<infer RE> ? EntityPropContributorCallbacks<RE> : F extends CreateFormPropsFactory<infer RCF> ? CreateFormPropContributorCallbacks<RCF> : F extends EditFormPropsFactory<infer REF> ? EditFormPropContributorCallbacks<REF> : never;
+export {};

package/extensible/lib/utils/state.util.d.ts

@@ -0,0 +1,5 @@
+import { ConfigStateService } from '@abp/ng.core';
+import { Observable } from 'rxjs';
+import { ObjectExtensions } from '../models/object-extensions';
+export declare function getObjectExtensionEntitiesFromStore(configState: ConfigStateService, moduleKey: string): Observable<ObjectExtensions.EntityExtensions>;
+export declare function mapEntitiesToContributors<T = any>(configState: ConfigStateService, resource: string): import("rxjs").UnaryFunction<Observable<any>, Observable<ObjectExtensions.PropContributors<any>>>;

package/extensible/lib/utils/typeahead.util.d.ts

@@ -0,0 +1,11 @@
+import { ABP, ExtensionPropertyUiLookupDto } from '@abp/ng.core';
+import { Observable } from 'rxjs';
+import { ePropType } from '../enums/props.enum';
+import { ObjectExtensions } from '../models/object-extensions';
+import { PropCallback } from '../models/props';
+export declare function createTypeaheadOptions(lookup: ExtensionPropertyUiLookupDto): PropCallback<any, Observable<ABP.Option<any>[]>>;
+export declare function getTypeaheadType(lookup: ExtensionPropertyUiLookupDto, name: string): ePropType.Hidden | ePropType.Typeahead;
+export declare function createTypeaheadDisplayNameGenerator(displayNameGeneratorFn: ObjectExtensions.DisplayNameGeneratorFn, properties: ObjectExtensions.EntityExtensionProperties): ObjectExtensions.DisplayNameGeneratorFn;
+export declare function addTypeaheadTextSuffix(name: string): string;
+export declare function hasTypeaheadTextSuffix(name: string): boolean;
+export declare function removeTypeaheadTextSuffix(name: string): string;

package/extensible/lib/utils/validation.util.d.ts

@@ -0,0 +1,3 @@
+import { ValidatorFn } from '@angular/forms';
+import { ObjectExtensions } from '../models/object-extensions';
+export declare function getValidatorsFromProperty(property: ObjectExtensions.ExtensionPropertyDto): ValidatorFn[];

package/extensible/public-api.d.ts

@@ -0,0 +1,26 @@
+export * from './lib/components/date-time-picker/extensible-date-time-picker.component';
+export * from './lib/components/extensible-form/extensible-form-prop.component';
+export * from './lib/components/extensible-form/extensible-form.component';
+export * from './lib/components/extensible-table/extensible-table.component';
+export * from './lib/components/grid-actions/grid-actions.component';
+export * from './lib/components/page-toolbar/page-toolbar.component';
+export * from './lib/constants/extra-properties';
+export * from './lib/directives/prop-data.directive';
+export * from './lib/enums/props.enum';
+export * from './lib/enums/components';
+export { ActionCallback, ActionList, ActionPredicate, ReadonlyActionData as ActionData, } from './lib/models/actions';
+export { EntityAction, EntityActionContributorCallback, EntityActionList, EntityActionOptions, EntityActions, EntityActionsFactory, } from './lib/models/entity-actions';
+export { EntityProp, EntityPropContributorCallback, EntityPropList, EntityPropOptions, EntityProps, EntityPropsFactory, } from './lib/models/entity-props';
+export { CreateFormPropContributorCallback, CreateFormPropsFactory, EditFormPropContributorCallback, EditFormPropsFactory, FormProp, FormPropData, FormPropList, FormPropOptions, FormProps, } from './lib/models/form-props';
+export * from './lib/models/object-extensions';
+export { PropCallback, PropList, PropPredicate, ReadonlyPropData as PropData, } from './lib/models/props';
+export { ToolbarAction, ToolbarActionContributorCallback, ToolbarActionList, ToolbarActionOptions, ToolbarActions, ToolbarActionsFactory, ToolbarComponent, ToolbarComponentOptions, } from './lib/models/toolbar-actions';
+export * from './lib/pipes/create-injector.pipe';
+export * from './lib/services/extensions.service';
+export * from './lib/tokens/extensions.token';
+export * from './lib/tokens/extensible-form-view-provider.token';
+export * from './lib/utils/actions.util';
+export * from './lib/utils/form-props.util';
+export * from './lib/utils/props.util';
+export * from './lib/utils/state.util';
+export * from './lib/extensible.module';

package/fesm2022/abp-ng.components-chart.js.mjs

@@ -80,8 +80,8 @@ class ChartComponent {
             this.initChart();
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.11", ngImport: i0, type: ChartComponent, deps: [{ token: i0.ElementRef }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.11", type: ChartComponent, selector: "abp-chart", inputs: { type: "type", data: "data", options: "options", plugins: "plugins", width: "width", height: "height", responsive: "responsive" }, outputs: { dataSelect: "dataSelect", initialized: "initialized" }, viewQueries: [{ propertyName: "canvas", first: true, predicate: ["canvas"], descendants: true }], exportAs: ["abpChart"], usesOnChanges: true, ngImport: i0, template: `
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.4", ngImport: i0, type: ChartComponent, deps: [{ token: i0.ElementRef }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.0.4", type: ChartComponent, selector: "abp-chart", inputs: { type: "type", data: "data", options: "options", plugins: "plugins", width: "width", height: "height", responsive: "responsive" }, outputs: { dataSelect: "dataSelect", initialized: "initialized" }, viewQueries: [{ propertyName: "canvas", first: true, predicate: ["canvas"], descendants: true }], exportAs: ["abpChart"], usesOnChanges: true, ngImport: i0, template: `
     <div
       style="position:relative"
       [style.width]="responsive && !width ? null : width"
@@ -96,7 +96,7 @@ class ChartComponent {
     </div>
   `, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.11", ngImport: i0, type: ChartComponent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.4", ngImport: i0, type: ChartComponent, decorators: [{
             type: Component,
             args: [{
                     selector: 'abp-chart',
@@ -117,7 +117,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.11", ngImpo
                     changeDetection: ChangeDetectionStrategy.OnPush,
                     exportAs: 'abpChart',
                 }]
-        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { type: [{
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.ChangeDetectorRef }], propDecorators: { type: [{
                 type: Input
             }], data: [{
                 type: Input
@@ -141,11 +141,11 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.11", ngImpo
             }] } });
 
 class ChartModule {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.11", ngImport: i0, type: ChartModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.11", ngImport: i0, type: ChartModule, declarations: [ChartComponent], imports: [CommonModule], exports: [ChartComponent] }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.11", ngImport: i0, type: ChartModule, imports: [CommonModule] }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.4", ngImport: i0, type: ChartModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.0.4", ngImport: i0, type: ChartModule, declarations: [ChartComponent], imports: [CommonModule], exports: [ChartComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.0.4", ngImport: i0, type: ChartModule, imports: [CommonModule] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.11", ngImport: i0, type: ChartModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.4", ngImport: i0, type: ChartModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [CommonModule],