@mintplayer/ng-spark 0.1.1 → 0.2.0

package/types/mintplayer-ng-spark-po-form.d.ts

@@ -0,0 +1,84 @@
+import * as _angular_core from '@angular/core';
+import { Type } from '@angular/core';
+import { Color } from '@mintplayer/ng-bootstrap';
+import { DatatableSettings } from '@mintplayer/ng-bootstrap/datatable';
+import { PaginationResponse } from '@mintplayer/pagination';
+import { EntityType, ValidationError, PersistentObject, LookupReference, EntityAttributeDefinition, EntityPermissions, LookupReferenceValue, ELookupDisplayType, AttributeTab, AttributeGroup } from '@mintplayer/ng-spark/models';
+
+declare class SparkPoFormComponent {
+    private readonly sparkService;
+    private readonly translations;
+    private readonly rendererRegistry;
+    entityType: _angular_core.InputSignal<EntityType>;
+    formData: _angular_core.ModelSignal<Record<string, any>>;
+    validationErrors: _angular_core.InputSignal<ValidationError[]>;
+    showButtons: _angular_core.InputSignal<boolean>;
+    isSaving: _angular_core.InputSignal<boolean>;
+    parentId: _angular_core.InputSignal<string>;
+    parentType: _angular_core.InputSignal<string>;
+    save: _angular_core.OutputEmitterRef<void>;
+    cancel: _angular_core.OutputEmitterRef<void>;
+    colors: typeof Color;
+    referenceOptions: _angular_core.WritableSignal<Record<string, PersistentObject[]>>;
+    asDetailTypes: _angular_core.WritableSignal<Record<string, EntityType>>;
+    lookupReferenceOptions: _angular_core.WritableSignal<Record<string, LookupReference>>;
+    editingAsDetailAttr: _angular_core.WritableSignal<EntityAttributeDefinition>;
+    asDetailFormData: _angular_core.WritableSignal<Record<string, any>>;
+    showAsDetailModal: _angular_core.WritableSignal<boolean>;
+    editingArrayIndex: _angular_core.WritableSignal<number>;
+    asDetailPermissions: _angular_core.WritableSignal<Record<string, EntityPermissions>>;
+    asDetailReferenceOptions: _angular_core.WritableSignal<Record<string, Record<string, PersistentObject[]>>>;
+    editingReferenceAttr: _angular_core.WritableSignal<EntityAttributeDefinition>;
+    showReferenceModal: _angular_core.WritableSignal<boolean>;
+    referenceModalItems: _angular_core.WritableSignal<PersistentObject[]>;
+    referenceModalEntityType: _angular_core.WritableSignal<EntityType>;
+    referenceModalPagination: _angular_core.WritableSignal<PaginationResponse<PersistentObject>>;
+    referenceModalSettings: _angular_core.WritableSignal<DatatableSettings>;
+    referenceSearchTerm: string;
+    editingLookupAttr: _angular_core.WritableSignal<EntityAttributeDefinition>;
+    showLookupModal: _angular_core.WritableSignal<boolean>;
+    lookupModalItems: _angular_core.WritableSignal<LookupReferenceValue[]>;
+    lookupSearchTerm: _angular_core.WritableSignal<string>;
+    ELookupDisplayType: typeof ELookupDisplayType;
+    editableAttributes: _angular_core.Signal<EntityAttributeDefinition[]>;
+    private static readonly DEFAULT_TAB;
+    ungroupedAttributes: _angular_core.Signal<EntityAttributeDefinition[]>;
+    resolvedTabs: _angular_core.Signal<AttributeTab[]>;
+    groupsForTab(tab: AttributeTab): AttributeGroup[];
+    attrsForGroup(group: AttributeGroup): EntityAttributeDefinition[];
+    referenceVisibleAttributes: _angular_core.Signal<EntityAttributeDefinition[]>;
+    filteredLookupItems: _angular_core.Signal<LookupReferenceValue[]>;
+    constructor();
+    private toRecord;
+    loadReferenceOptions(): Promise<void>;
+    loadAsDetailTypes(): Promise<void>;
+    loadLookupReferenceOptions(): Promise<void>;
+    getReferenceOptions(attr: EntityAttributeDefinition): PersistentObject[];
+    getLookupOptions(attr: EntityAttributeDefinition): LookupReferenceValue[];
+    openLookupSelector(attr: EntityAttributeDefinition): void;
+    selectLookupItem(item: LookupReferenceValue): void;
+    closeLookupModal(): void;
+    getEditRendererComponent(attr: EntityAttributeDefinition): Type<any> | null;
+    getEditRendererInputs(attr: EntityAttributeDefinition): Record<string, any>;
+    hasError(attrName: string): boolean;
+    onFieldChange(): void;
+    onSave(): void;
+    onCancel(): void;
+    openAsDetailEditor(attr: EntityAttributeDefinition): void;
+    saveAsDetailObject(): void;
+    closeAsDetailModal(): void;
+    addInlineRow(attr: EntityAttributeDefinition): void;
+    addArrayItem(attr: EntityAttributeDefinition): void;
+    editArrayItem(attr: EntityAttributeDefinition, index: number): void;
+    removeArrayItem(attr: EntityAttributeDefinition, index: number): void;
+    openReferenceSelector(attr: EntityAttributeDefinition): Promise<void>;
+    onReferenceSearchChange(): void;
+    applyReferenceFilter(): void;
+    clearReferenceSearch(): void;
+    selectReferenceItem(item: PersistentObject): void;
+    closeReferenceModal(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SparkPoFormComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SparkPoFormComponent, "spark-po-form", never, { "entityType": { "alias": "entityType"; "required": false; "isSignal": true; }; "formData": { "alias": "formData"; "required": false; "isSignal": true; }; "validationErrors": { "alias": "validationErrors"; "required": false; "isSignal": true; }; "showButtons": { "alias": "showButtons"; "required": false; "isSignal": true; }; "isSaving": { "alias": "isSaving"; "required": false; "isSignal": true; }; "parentId": { "alias": "parentId"; "required": false; "isSignal": true; }; "parentType": { "alias": "parentType"; "required": false; "isSignal": true; }; }, { "formData": "formDataChange"; "save": "save"; "cancel": "cancel"; }, never, never, true, never>;
+}
+
+export { SparkPoFormComponent };

package/types/mintplayer-ng-spark-query-list.d.ts

@@ -0,0 +1,60 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef, Type } from '@angular/core';
+import { Color } from '@mintplayer/ng-bootstrap';
+import { DatatableSettings } from '@mintplayer/ng-bootstrap/datatable';
+import { VirtualDatatableDataSource } from '@mintplayer/ng-bootstrap/virtual-datatable';
+import { PaginationResponse } from '@mintplayer/pagination';
+import { PersistentObject, SparkQuery, EntityType, LookupReference, EntityAttributeDefinition } from '@mintplayer/ng-spark/models';
+
+declare class SparkQueryListComponent {
+    private readonly route;
+    private readonly router;
+    private readonly sparkService;
+    private readonly streamingService;
+    private readonly rendererRegistry;
+    private readonly destroyRef;
+    extraActionsTemplate: _angular_core.InputSignal<TemplateRef<void>>;
+    rowClicked: _angular_core.OutputEmitterRef<PersistentObject>;
+    createClicked: _angular_core.OutputEmitterRef<void>;
+    colors: typeof Color;
+    errorMessage: _angular_core.WritableSignal<string>;
+    query: _angular_core.WritableSignal<SparkQuery>;
+    entityType: _angular_core.WritableSignal<EntityType>;
+    allEntityTypes: _angular_core.WritableSignal<EntityType[]>;
+    lookupReferenceOptions: _angular_core.WritableSignal<Record<string, LookupReference>>;
+    paginationData: _angular_core.WritableSignal<PaginationResponse<PersistentObject>>;
+    searchTerm: string;
+    canRead: _angular_core.WritableSignal<boolean>;
+    canCreate: _angular_core.WritableSignal<boolean>;
+    isStreaming: _angular_core.WritableSignal<boolean>;
+    private streamingSub;
+    private allItems;
+    private filteredItems;
+    settings: _angular_core.WritableSignal<DatatableSettings>;
+    virtualDataSource: _angular_core.WritableSignal<VirtualDatatableDataSource<PersistentObject>>;
+    virtualSettings: _angular_core.WritableSignal<DatatableSettings>;
+    constructor();
+    private onParamsChange;
+    private resolveEntityTypeForQuery;
+    private extractSourceName;
+    private singularize;
+    private initVirtualDataSource;
+    loadItems(): Promise<void>;
+    onSettingsChange(): void;
+    onSearchChange(): void;
+    clearSearch(): void;
+    isVirtualScrolling: _angular_core.Signal<boolean>;
+    visibleAttributes: _angular_core.Signal<EntityAttributeDefinition[]>;
+    getColumnRendererComponent(attr: EntityAttributeDefinition): Type<any> | null;
+    getColumnRendererInputs(item: PersistentObject, attr: EntityAttributeDefinition): Record<string, any>;
+    private loadLookupReferenceOptions;
+    onCreate(): void;
+    private connectStreaming;
+    private disconnectStreaming;
+    private handleStreamingMessage;
+    private applyFilter;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SparkQueryListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SparkQueryListComponent, "spark-query-list", never, { "extraActionsTemplate": { "alias": "extraActionsTemplate"; "required": false; "isSignal": true; }; }, { "rowClicked": "rowClicked"; "createClicked": "createClicked"; }, never, never, true, never>;
+}
+
+export { SparkQueryListComponent };

package/types/mintplayer-ng-spark-renderers.d.ts

@@ -0,0 +1,68 @@
+import { InputSignal, InjectionToken, Type, Provider } from '@angular/core';
+import { EntityAttributeDefinition } from '@mintplayer/ng-spark/models';
+
+/**
+ * Contract for detail-page renderers (spark-po-detail).
+ * Displays a single attribute value in the PO detail view.
+ */
+interface SparkAttributeDetailRenderer {
+    /** The current attribute value */
+    value: InputSignal<any>;
+    /** The attribute definition metadata */
+    attribute: InputSignal<EntityAttributeDefinition | undefined>;
+    /** Renderer-specific options from rendererOptions */
+    options: InputSignal<Record<string, any> | undefined>;
+    /** The full form data (for cross-field dependencies) */
+    formData: InputSignal<Record<string, any>>;
+}
+/**
+ * Contract for query-list column renderers (spark-query-list).
+ * Displays a compact cell value in the list/grid view.
+ */
+interface SparkAttributeColumnRenderer {
+    /** The current attribute value */
+    value: InputSignal<any>;
+    /** The attribute definition metadata */
+    attribute: InputSignal<EntityAttributeDefinition | undefined>;
+    /** Renderer-specific options from rendererOptions */
+    options: InputSignal<Record<string, any> | undefined>;
+}
+/**
+ * Contract for edit-form renderers (spark-po-form on create/edit pages).
+ * Replaces the default <input> for this attribute.
+ */
+interface SparkAttributeEditRenderer {
+    /** The current attribute value */
+    value: InputSignal<any>;
+    /** The attribute definition metadata */
+    attribute: InputSignal<EntityAttributeDefinition | undefined>;
+    /** Renderer-specific options from rendererOptions */
+    options: InputSignal<Record<string, any> | undefined>;
+    /** Callback to notify parent form of value changes (since NgComponentOutlet doesn't support outputs) */
+    valueChange: InputSignal<(value: any) => void>;
+}
+
+interface SparkAttributeRendererRegistration {
+    /** The renderer name (must match attr.renderer in model JSON) */
+    name: string;
+    /** Component for the PO detail page. Must implement SparkAttributeDetailRenderer. */
+    detailComponent: Type<any>;
+    /** Component for query-list column cells. Must implement SparkAttributeColumnRenderer. */
+    columnComponent: Type<any>;
+    /** Optional component for create/edit forms. Must implement SparkAttributeEditRenderer. When omitted, the default input is used. */
+    editComponent?: Type<any>;
+}
+declare const SPARK_ATTRIBUTE_RENDERERS: InjectionToken<SparkAttributeRendererRegistration[]>;
+/**
+ * Register custom attribute renderers globally.
+ *
+ * @example
+ * provideSparkAttributeRenderers([
+ *   { name: 'video-player', detailComponent: VideoDetailComponent, columnComponent: VideoColumnComponent },
+ *   { name: 'color-swatch', detailComponent: ColorDetailComponent, columnComponent: ColorColumnComponent },
+ * ])
+ */
+declare function provideSparkAttributeRenderers(renderers: SparkAttributeRendererRegistration[]): Provider;
+
+export { SPARK_ATTRIBUTE_RENDERERS, provideSparkAttributeRenderers };
+export type { SparkAttributeColumnRenderer, SparkAttributeDetailRenderer, SparkAttributeEditRenderer, SparkAttributeRendererRegistration };

package/types/mintplayer-ng-spark-retry-action-modal.d.ts

@@ -0,0 +1,14 @@
+import * as i0 from '@angular/core';
+import { Color } from '@mintplayer/ng-bootstrap';
+import { RetryActionService } from '@mintplayer/ng-spark/services';
+
+declare class SparkRetryActionModalComponent {
+    protected readonly retryActionService: RetryActionService;
+    colors: typeof Color;
+    isOpen: i0.Signal<boolean>;
+    onOption(option: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SparkRetryActionModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SparkRetryActionModalComponent, "spark-retry-action-modal", never, {}, {}, never, never, true, never>;
+}
+
+export { SparkRetryActionModalComponent };

package/types/mintplayer-ng-spark-routes.d.ts

@@ -0,0 +1,12 @@
+import { Route, Routes } from '@angular/router';
+
+interface SparkRouteConfig {
+    queryList?: Route['loadComponent'];
+    poCreate?: Route['loadComponent'];
+    poEdit?: Route['loadComponent'];
+    poDetail?: Route['loadComponent'];
+}
+declare function sparkRoutes(config?: SparkRouteConfig): Routes;
+
+export { sparkRoutes };
+export type { SparkRouteConfig };

package/types/mintplayer-ng-spark-services.d.ts

@@ -0,0 +1,100 @@
+import * as i0 from '@angular/core';
+import { RetryActionPayload, RetryActionResult, TranslatedString, StreamingMessage, EntityType, EntityPermissions, SparkQuery, QueryResult, ProgramUnitsConfiguration, PersistentObject, CustomActionDefinition, LookupReferenceListItem, LookupReference, LookupReferenceValue } from '@mintplayer/ng-spark/models';
+import { Observable } from 'rxjs';
+import { SortColumn } from '@mintplayer/pagination';
+import { SafeHtml } from '@angular/platform-browser';
+
+declare class RetryActionService {
+    private resolveRetry;
+    payload: i0.WritableSignal<RetryActionPayload>;
+    show(payload: RetryActionPayload): Promise<RetryActionResult>;
+    respond(result: RetryActionResult): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RetryActionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RetryActionService>;
+}
+
+declare class SparkLanguageService {
+    private readonly http;
+    private readonly config;
+    private readonly baseUrl;
+    private readonly currentLang;
+    private readonly translationsMap;
+    readonly language: i0.Signal<string>;
+    readonly languages: i0.WritableSignal<Record<string, TranslatedString>>;
+    constructor();
+    private loadCulture;
+    private loadTranslations;
+    setLanguage(lang: string): void;
+    resolve(ts: TranslatedString | undefined): string;
+    t(key: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SparkLanguageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SparkLanguageService>;
+}
+
+declare class SparkStreamingService {
+    private readonly config;
+    private readonly baseUrl;
+    private readonly ngZone;
+    connectToStreamingQuery(queryId: string): Observable<StreamingMessage>;
+    private buildWebSocketUrl;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SparkStreamingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SparkStreamingService>;
+}
+
+declare class SparkService {
+    private readonly config;
+    private readonly baseUrl;
+    private readonly http;
+    private readonly retryActionService;
+    getEntityTypes(): Promise<EntityType[]>;
+    getEntityType(id: string): Promise<EntityType>;
+    getEntityTypeByClrType(clrType: string): Promise<EntityType | undefined>;
+    getPermissions(entityTypeId: string): Promise<EntityPermissions>;
+    getQueries(): Promise<SparkQuery[]>;
+    getQuery(id: string): Promise<SparkQuery>;
+    getQueryByName(name: string): Promise<SparkQuery | undefined>;
+    executeQuery(queryId: string, options?: {
+        sortColumns?: SortColumn[];
+        parentId?: string;
+        parentType?: string;
+        skip?: number;
+        take?: number;
+        search?: string;
+    }): Promise<QueryResult>;
+    executeQueryByName(queryName: string, options?: {
+        parentId?: string;
+        parentType?: string;
+    }): Promise<QueryResult>;
+    getProgramUnits(): Promise<ProgramUnitsConfiguration>;
+    list(type: string): Promise<PersistentObject[]>;
+    get(type: string, id: string): Promise<PersistentObject>;
+    create(type: string, data: Partial<PersistentObject>): Promise<PersistentObject>;
+    update(type: string, id: string, data: Partial<PersistentObject>): Promise<PersistentObject>;
+    delete(type: string, id: string): Promise<void>;
+    getCustomActions(objectTypeId: string): Promise<CustomActionDefinition[]>;
+    executeCustomAction(objectTypeId: string, actionName: string, parent?: PersistentObject, selectedItems?: PersistentObject[]): Promise<void>;
+    getLookupReferences(): Promise<LookupReferenceListItem[]>;
+    getLookupReference(name: string): Promise<LookupReference>;
+    addLookupReferenceValue(name: string, value: LookupReferenceValue): Promise<LookupReferenceValue>;
+    updateLookupReferenceValue(name: string, key: string, value: LookupReferenceValue): Promise<LookupReferenceValue>;
+    deleteLookupReferenceValue(name: string, key: string): Promise<void>;
+    private postWithRetry;
+    private putWithRetry;
+    private deleteWithRetry;
+    private handleRetryError;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SparkService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SparkService>;
+}
+
+declare class SparkIconRegistry {
+    private sanitizer;
+    private icons;
+    constructor();
+    register(name: string, svg: string): void;
+    get(name: string): SafeHtml | undefined;
+    has(name: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SparkIconRegistry, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SparkIconRegistry>;
+}
+
+export { RetryActionService, SparkIconRegistry, SparkLanguageService, SparkService, SparkStreamingService };