@veloceapps/sdk 7.0.2-6 → 7.0.2-60

package/core/modules/configuration/services/configuration.service.d.ts

@@ -1,5 +1,5 @@
 import { ConfigurationApiService } from '@veloceapps/api';
-import { Charge, CompiledPricePlan, ConfigurationContext, LineItem, RuntimeModel } from '@veloceapps/core';
+import { Charge, CompiledPricePlan, ConfigurationContext, LineItem, PatchLineItemOptions, RuntimeModel } from '@veloceapps/core';
 import { Dictionary } from 'lodash';
 import { MessageService } from 'primeng/api';
 import { DialogService } from 'primeng/dynamicdialog';
@@ -24,8 +24,8 @@ export declare class ConfigurationService {
     hasUnsavedChanges: boolean;
     constructor(quoteDraftService: QuoteDraftService, runtimeService: ConfigurationRuntimeService, contextService: ContextService, configurationApiService: ConfigurationApiService, messageService: MessageService, dialogService: DialogService);
     reset(): void;
-    patch$(lineItem: LineItem): Observable<LineItem>;
-    patch(lineItem: LineItem): void;
+    patch$(lineItem: LineItem, options?: PatchLineItemOptions): Observable<LineItem>;
+    patch(lineItem: LineItem, options?: PatchLineItemOptions): void;
     setConfigurableRamp(lineItem: LineItem): void;
     get(): Observable<LineItem | undefined>;
     getSnapshot(): LineItem | undefined;

package/core/pipes/date.pipe.d.ts

@@ -0,0 +1,12 @@
+import { OnDestroy, PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class DatePipe implements PipeTransform, OnDestroy {
+    private locale;
+    private defaultOptions;
+    private formattingSettings;
+    private destroy$;
+    ngOnDestroy(): void;
+    transform(date: string | number | Date | undefined | null): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<DatePipe, "vlDate", false>;
+}

package/core/pipes/index.d.ts

@@ -0,0 +1,4 @@
+export * from './date.pipe';
+export * from './number.pipe';
+export * from './pipes.module';
+export * from './price.pipe';

package/core/pipes/number.pipe.d.ts

@@ -0,0 +1,10 @@
+import { OnDestroy, PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class NumberPipe implements PipeTransform, OnDestroy {
+    private formattingSettings;
+    private destroy$;
+    ngOnDestroy(): void;
+    transform(price: string | number): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NumberPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<NumberPipe, "vlNumber", false>;
+}

package/core/pipes/pipes.module.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./number.pipe";
+import * as i2 from "./price.pipe";
+import * as i3 from "./date.pipe";
+export declare class SdkPipesModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SdkPipesModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SdkPipesModule, [typeof i1.NumberPipe, typeof i2.PricePipe, typeof i3.DatePipe], never, [typeof i1.NumberPipe, typeof i2.PricePipe, typeof i3.DatePipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SdkPipesModule>;
+}

package/core/pipes/price.pipe.d.ts

@@ -0,0 +1,10 @@
+import { OnDestroy, PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class PricePipe implements PipeTransform, OnDestroy {
+    private formattingSettings;
+    private destroy$;
+    ngOnDestroy(): void;
+    transform(price: string | number): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PricePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PricePipe, "vlPrice", false>;
+}

package/core/services/index.d.ts

@@ -2,3 +2,4 @@ export * from './context.service';
 export * from './metric-calculation/metric-calculation.service';
 export * from './product-images.service';
 export * from './quote-draft.service';
+export * from './runtime-settings.service';

package/core/services/runtime-settings.service.d.ts

@@ -0,0 +1,21 @@
+import { ConfigurationSettingsApiService } from '@veloceapps/api';
+import { RuntimeConfigurationSettings, RuntimeCurrencySettings } from '@veloceapps/core';
+import { Observable } from 'rxjs';
+import { FormattingSettings } from '../types';
+import * as i0 from "@angular/core";
+export declare class RuntimeSettingsService {
+    private configurationSettingsApiService;
+    private configurationSettings$;
+    private currencySettings$;
+    private formattingSettings;
+    constructor(configurationSettingsApiService: ConfigurationSettingsApiService);
+    create(): Observable<void>;
+    initCurrency(iso?: string): void;
+    getFormattingSettings(): FormattingSettings;
+    getConfigurationSettings(): RuntimeConfigurationSettings;
+    getCurrencySettings(): RuntimeCurrencySettings;
+    private parseConfigurationSettings;
+    private getCurrencySymbol;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RuntimeSettingsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RuntimeSettingsService>;
+}

package/core/types/formatting-settings.types.d.ts

@@ -0,0 +1,11 @@
+import { InjectionToken } from '@angular/core';
+import { Prettify, VlDateSettings } from '@veloceapps/core';
+export declare const FORMATTING_SETTINGS_TOKEN: InjectionToken<{
+    getFormattingSettings: (...args: unknown[]) => FormattingSettings;
+}>;
+export type FormattingSettings = Prettify<{
+    currencySymbol: string;
+    thousandsSeparator: string;
+    decimalSeparator: string;
+    decimalsCount: number;
+} & VlDateSettings>;

package/core/types/index.d.ts

@@ -1,2 +1,3 @@
+export * from './formatting-settings.types';
 export * from './runtime.types';
 export * from './ui-definition.types';

package/core/types/runtime.types.d.ts

@@ -1,5 +1,4 @@
-import { ContextProperties, RuntimeModel } from '@veloceapps/core';
-import { UIDefinition } from './ui-definition.types';
+import { ContextProperties, RuntimeModel, UIDefinition } from '@veloceapps/core';
 export declare enum RuntimeMode {
     TEST = 0,
     PROD = 1

package/core/types/ui-definition.types.d.ts

@@ -1,41 +1 @@
-export type UIDefinitionType = 'DEFAULT' | 'CONFIGURATION';
 export declare const UI_DEFINITION_VERSION = 3;
-export type UIExternalsType = Record<string, string | number | boolean>;
-export interface UIDefinitionProps {
-    suppressToastMessages?: boolean;
-    rootType?: string;
-    pricingEnabled?: boolean;
-    priceList?: string;
-    productId?: string;
-}
-export interface UIDefinitionMetadata {
-    name: string;
-    type: UIDefinitionType;
-    properties?: UIDefinitionProps;
-    primary: boolean;
-    createdTimestamp: number;
-    externals?: UIExternalsType;
-    version: number;
-}
-export interface UIDefinition extends UIDefinitionMetadata {
-    /**
-     * `children` is for simple previews only.
-     * For applications use `pages` property instead
-     */
-    children?: UIElement[];
-    /**
-     * The page is an Element with `type: 'PAGE'`
-     */
-    pages?: UIElement[];
-    /**
-     * Shared components
-     * These are not rendered on the screen, and only used by REFERENCE type elements
-     */
-    components?: UIElement[];
-}
-export interface UIElement {
-    children: UIElement[];
-    template?: string;
-    script?: string;
-    styles?: string;
-}

package/core/utils/line-item.utils.d.ts

@@ -4,7 +4,7 @@ export declare const findLineItem: (id: string, lineItems: LineItem[]) => LineIt
 export declare const findLineItemWithComparator: (lineItems: LineItem[], comparator: (li: LineItem) => boolean) => LineItem | undefined;
 export declare const insertLineItem: (lineItem: LineItem, parentId: string, toInsert: LineItem) => LineItem;
 export declare const removeLineItem: (lineItem: LineItem, idToRemove: string) => LineItem;
-export declare const replaceLineItem: (lineItem: LineItem, replaceTo: LineItem) => LineItem;
+export declare const replaceLineItem: (lineItem: LineItem, replaceTo: LineItem, skipCardinalityCalculation?: boolean) => LineItem;
 export declare const calculateCardinalityVariables: (lineItems: LineItem[]) => Map<string, number>;
 export declare const recalculateCardinalityVariables: (original: LineItem, updated: LineItem) => LineItem;
 export declare const mapAttributes: (attributes: Attribute[]) => Dictionary<any>;
@@ -16,7 +16,7 @@ export declare const upsertAttributes: (originalAttributes: Attribute[], attribu
 export declare const patchAttributes: (rootLineItem: LineItem, id: string, attrs: {
     name: string;
     value: any;
-}[]) => LineItem;
+}[], skipCardinalityCalculation?: boolean) => LineItem;
 export declare const getAttributeValue: (attributes: Attribute[], name: string) => any;
 export declare const generateLineItem: (port: string, type: string, parentId: string, attributes?: {
     name: string;
@@ -28,5 +28,8 @@ export declare const getRecommendedPrices: (portDomain: PortDomain, type: string
 };
 export declare const generateModifiedAssetsMap: (lineItems: LineItem[]) => Record<string, boolean>;
 export declare const getOriginParent: (lineItems: LineItem[], currentLineItem: LineItem) => LineItem | undefined;
-export declare const isLineItemModified: (lineItem: LineItem) => boolean;
+export declare const isLineItemModified: <T extends Pick<LineItem, "actionCode" | "status">>(lineItem: T) => boolean;
 export declare const multiplyLineItems: (lineItem: LineItem, qty: number, split: boolean) => LineItem[];
+export declare const filterOutTechnicalAttributes: <T extends {
+    name: string;
+}>(attributes: T[]) => T[];

package/core/utils/line-item.worker.d.ts

@@ -4,9 +4,9 @@ export declare class LineItemWorker {
     constructor(src: LineItem);
     insert(parentId: string, toInsert: LineItem): LineItemWorker;
     remove(id: string): LineItemWorker;
-    replace(toReplace: LineItem): LineItemWorker;
+    replace(toReplace: LineItem, skipCardinalityCalculation?: boolean): LineItemWorker;
     patchAttribute(attrs: {
         name: string;
         value: any;
-    }[], id?: string): LineItemWorker;
+    }[], id?: string, skipCardinalityCalculation?: boolean): LineItemWorker;
 }

package/core/utils/ui-definition.utils.d.ts

@@ -1,2 +1,2 @@
-import { UIDefinition, UIDefinitionMetadata } from '../types';
+import { UIDefinition, UIDefinitionMetadata } from '@veloceapps/core';
 export declare function extractMetadata(uiDefinition: UIDefinition): UIDefinitionMetadata;

package/esm2020/cms/cms.actions.mjs

@@ -42,15 +42,55 @@ export const SwitchObjectAction = (payload) => ({
 export var CmsAction;
 (function (CmsAction) {
     CmsAction.GO_TO_PAGE = '[CMS]_GO_TO_PAGE';
+    CmsAction.UPDATE_CUSTOMIZATION = '[CMS]_UPDATE_CUSTOMIZATION';
+    CmsAction.SHOW_OVERLAY = '[CMS]_SHOW_OVERLAY';
+    CmsAction.HIDE_OVERLAY = '[CMS]_HIDE_OVERLAY';
+    CmsAction.HIDE_ALL_OVERLAYS = '[CMS]_HIDE_ALL_OVERLAYS';
     /**
      * Navigate UI definition to a specific page
      *
      * @param pageName name of the page
-     * @returns void
      */
     CmsAction.GoToPage = (pageName) => ({
         type: CmsAction.GO_TO_PAGE,
         payload: { pageName },
     });
+    /**
+     * Update UI definition customization state
+     *
+     * @param pageName name of the page
+     */
+    CmsAction.UpdateCustomization = (value) => ({
+        type: CmsAction.UPDATE_CUSTOMIZATION,
+        payload: { value },
+    });
+    /**
+     * Show an Overlay on the selected page
+     *
+     * @param name - name of the overlay
+     * @returns void
+     */
+    CmsAction.ShowOverlay = (name) => ({
+        type: CmsAction.SHOW_OVERLAY,
+        payload: { name },
+    });
+    /**
+     * Hide an Overlay on the selected page
+     *
+     * @param name - name of the overlay
+     * @returns void
+     */
+    CmsAction.HideOverlay = (name) => ({
+        type: CmsAction.HIDE_OVERLAY,
+        payload: { name },
+    });
+    /**
+     * Hide all Overlays on the selected page
+     *
+     * @returns void
+     */
+    CmsAction.HideAllOverlays = () => ({
+        type: CmsAction.HIDE_ALL_OVERLAYS,
+    });
 })(CmsAction || (CmsAction = {}));
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/cms/cms.default.mjs

@@ -3,4 +3,4 @@ export const DEFAULT_PLUGINS = {
     CONFIGURATION: [ConfigurationPlugin],
     DEFAULT: [],
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY21zLmRlZmF1bHQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL3Nkay9jbXMvY21zLmRlZmF1bHQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFFckUsTUFBTSxDQUFDLE1BQU0sZUFBZSxHQUFtRDtJQUM3RSxhQUFhLEVBQUUsQ0FBQyxtQkFBbUIsQ0FBQztJQUNwQyxPQUFPLEVBQUUsRUFBRTtDQUNaLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBVSURlZmluaXRpb25UeXBlIH0gZnJvbSAnQHZlbG9jZWFwcHMvc2RrL2NvcmUnO1xuaW1wb3J0IHsgUGx1Z2luIH0gZnJvbSAnLi9lbmdpbmUvbW9kZWxzL3BsdWdpbic7XG5pbXBvcnQgeyBDb25maWd1cmF0aW9uUGx1Z2luIH0gZnJvbSAnLi9wbHVnaW5zL2NvbmZpZ3VyYXRpb24ucGx1Z2luJztcblxuZXhwb3J0IGNvbnN0IERFRkFVTFRfUExVR0lOUzogeyBba2V5IGluIFVJRGVmaW5pdGlvblR5cGVdOiB0eXBlb2YgUGx1Z2luW10gfSA9IHtcbiAgQ09ORklHVVJBVElPTjogW0NvbmZpZ3VyYXRpb25QbHVnaW5dLFxuICBERUZBVUxUOiBbXSxcbn07XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY21zLmRlZmF1bHQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL3Nkay9jbXMvY21zLmRlZmF1bHQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFFckUsTUFBTSxDQUFDLE1BQU0sZUFBZSxHQUFxRDtJQUMvRSxhQUFhLEVBQUUsQ0FBQyxtQkFBbUIsQ0FBQztJQUNwQyxPQUFPLEVBQUUsRUFBRTtDQUNaLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBVSURlZmluaXRpb25UeXBlIH0gZnJvbSAnQHZlbG9jZWFwcHMvY29yZSc7XG5pbXBvcnQgeyBQbHVnaW4gfSBmcm9tICcuL2VuZ2luZS9tb2RlbHMvcGx1Z2luJztcbmltcG9ydCB7IENvbmZpZ3VyYXRpb25QbHVnaW4gfSBmcm9tICcuL3BsdWdpbnMvY29uZmlndXJhdGlvbi5wbHVnaW4nO1xuXG5leHBvcnQgY29uc3QgREVGQVVMVF9QTFVHSU5TOiB7IFtrZXkgaW4gVUlEZWZpbml0aW9uVHlwZV06ICh0eXBlb2YgUGx1Z2luKVtdIH0gPSB7XG4gIENPTkZJR1VSQVRJT046IFtDb25maWd1cmF0aW9uUGx1Z2luXSxcbiAgREVGQVVMVDogW10sXG59O1xuIl19

package/esm2020/cms/cms.elements.mjs

@@ -1,15 +1,21 @@
 import { ElementComponent } from './components/element.component';
+import { ElementHoverPlugin } from './plugins/element-hover.plugin';
 import { IOPlugin } from './plugins/io.plugin';
+import { PagePlugin } from './plugins/page.plugin';
 import { RegionPlugin } from './plugins/region.plugin';
 import { ScriptPlugin } from './plugins/script.plugin';
 /*
  * ScriptPlugin must always be the last plugin in the list to make sure user code is running after all pre-initializers.
  */
 export const CONFIG = {
-    CUSTOM: {
+    CUSTOMIZATION_PAGE: {
         component: ElementComponent,
         plugins: [IOPlugin, ScriptPlugin],
     },
+    CUSTOM: {
+        component: ElementComponent,
+        plugins: [IOPlugin, ElementHoverPlugin, ScriptPlugin],
+    },
     CONTAINER: {
         component: ElementComponent,
         defaultTemplate: '<element-children></element-children>',
@@ -29,12 +35,18 @@ export const CONFIG = {
     PAGE: {
         component: ElementComponent,
         defaultTemplate: '<element-children></element-children>',
-        plugins: [IOPlugin, ScriptPlugin],
+        plugins: [IOPlugin, ScriptPlugin, PagePlugin],
+        builder: {
+            suppressRemovable: true,
+        },
     },
     REGION: {
         component: ElementComponent,
         defaultTemplate: '<element-children></element-children>',
-        plugins: [IOPlugin, ScriptPlugin, RegionPlugin],
+        plugins: [IOPlugin, RegionPlugin, ElementHoverPlugin, ScriptPlugin],
+        builder: {
+            suppressRemovable: true,
+        },
     },
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/cms/cms.layouts.mjs

@@ -1,5 +1,7 @@
 export const LAYOUT = {
     LAYOUT_1: {
+        hasHeader: true,
+        hasFooter: true,
         styles: `
 /* start of LAYOUT_1 styles */
 :host {
@@ -10,8 +12,7 @@ export const LAYOUT = {
     "main" 1fr
     "footer" auto
     / 1fr;
-  gap: 10px;
-  padding: 10px;
+  gap: 16px;
 }
 
 :host ::ng-deep element-children > vl-cms-element-renderer {
@@ -33,6 +34,8 @@ export const LAYOUT = {
 `,
     },
     LAYOUT_2: {
+        hasHeader: true,
+        hasFooter: true,
         styles: `
 /* start of LAYOUT_2 styles */
 :host {
@@ -43,8 +46,7 @@ export const LAYOUT = {
     "left right" 1fr
     "footer footer" auto
     / 1fr 1fr;
-  gap: 10px;
-  padding: 10px;
+  gap: 16px;
 }
 
 :host ::ng-deep element-children > vl-cms-element-renderer {
@@ -70,6 +72,8 @@ export const LAYOUT = {
 `,
     },
     LAYOUT_3: {
+        hasHeader: false,
+        hasFooter: true,
         styles: `
 /* start of LAYOUT_3 styles */
 :host {
@@ -79,8 +83,7 @@ export const LAYOUT = {
     "main" 1fr
     "footer" auto
     / 1fr;
-  gap: 10px;
-  padding: 10px;
+  gap: 16px;
 }
 
 :host ::ng-deep element-children > vl-cms-element-renderer {
@@ -97,6 +100,8 @@ export const LAYOUT = {
 `,
     },
     LAYOUT_4: {
+        hasHeader: false,
+        hasFooter: true,
         styles: `
 /* start of LAYOUT_4 styles */
 :host {
@@ -106,8 +111,7 @@ export const LAYOUT = {
     "left right" 1fr
     "footer footer" auto
     / auto auto;
-  gap: 10px;
-  padding: 10px;
+  gap: 16px;
 }
 
 :host ::ng-deep element-children > vl-cms-element-renderer {
@@ -128,6 +132,8 @@ export const LAYOUT = {
 `,
     },
     LAYOUT_5: {
+        hasHeader: true,
+        hasFooter: false,
         styles: `
 /* start of LAYOUT_5 styles */
 :host {
@@ -137,8 +143,7 @@ export const LAYOUT = {
     "header" auto
     "main" 1fr
     / 1fr;
-  gap: 10px;
-  padding: 10px;
+  gap: 16px;
 }
 
 :host ::ng-deep element-children > vl-cms-element-renderer {
@@ -155,6 +160,8 @@ export const LAYOUT = {
 `,
     },
     LAYOUT_6: {
+        hasHeader: false,
+        hasFooter: false,
         styles: `
 /* start of LAYOUT_6 styles */
 :host {
@@ -163,8 +170,7 @@ export const LAYOUT = {
   grid:
     "main" 1fr
     / 1fr;
-  gap: 10px;
-  padding: 10px;
+  gap: 16px;
 }
 
 :host ::ng-deep element-children > vl-cms-element-renderer {
@@ -173,7 +179,61 @@ export const LAYOUT = {
   }
 }
 /* end of LAYOUT_6 styles */
+`,
+    },
+    LAYOUT_7: {
+        hasHeader: false,
+        hasFooter: false,
+        styles: `
+    /* start of LAYOUT_7 styles */
+    :host {
+      position: absolute;
+      left: 300px;
+      background: #ffffff;
+      box-shadow: 0px 4px 20px rgba(0, 41, 87, 0.12);
+      display: grid;
+      grid: "left" 1fr / 1fr;
+      gap: 16px;
+      justify-content: start;
+      min-width: calc(100% / 3);
+      height: fill-available;
+      height: -webkit-fill-available;
+      height: -moz-available;
+    }
+    :host ::ng-deep element-children > vl-cms-element-renderer {
+      &:nth-child(1) > vl-element {
+        grid-area: left;
+      }
+    }
+    /* end of LAYOUT_7 styles */
+`,
+    },
+    LAYOUT_8: {
+        hasHeader: false,
+        hasFooter: false,
+        styles: `
+    /* start of LAYOUT_8 styles */
+    :host {
+      position: absolute;
+      right: 0;
+      background: #ffffff;
+      box-shadow: 0px 4px 20px rgba(0, 41, 87, 0.12);
+      display: grid;
+      grid: "right" 1fr / 1fr;
+      gap: 16px;
+      justify-content: end;
+      min-width: calc(100% / 3);
+      height: fill-available;
+      height: -webkit-fill-available;
+      height: -moz-available;
+    }
+    :host ::ng-deep element-children > vl-cms-element-renderer {
+      &:nth-child(1) > vl-element {
+        grid-area: right;
+      }
+    }
+    /* end of LAYOUT_8 styles */
 `,
     },
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/cms/components/element-children/element-children.component.mjs

@@ -1,5 +1,5 @@
-import { ChangeDetectionStrategy, ChangeDetectorRef, Component } from '@angular/core';
-import { combineLatest, map, of, Subject, takeUntil } from 'rxjs';
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, Input } from '@angular/core';
+import { Subject, combineLatest, map, of, takeUntil } from 'rxjs';
 import { RuntimeEditorService } from '../../modules/runtime/services/runtime-editor.service';
 import { RuntimeService } from '../../modules/runtime/services/runtime.service';
 import { ElementContextService } from '../../services/element-context.service';
@@ -26,11 +26,16 @@ export class ElementChildrenComponent {
         this.destroyed$.next();
         this.destroyed$.complete();
     }
+    getFilteredChildren(elements) {
+        return this.filter ? this.filter(elements) : elements;
+    }
 }
 ElementChildrenComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: ElementChildrenComponent, deps: [{ token: i1.ElementContextService }, { token: i2.RuntimeService }, { token: i3.RuntimeEditorService }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
-ElementChildrenComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.8", type: ElementChildrenComponent, selector: "element-children", ngImport: i0, template: "<ng-container *ngIf=\"metadata$ | async as metadata\">\n  <vl-element-drop-handle *ngIf=\"dragMode$ | async\" [index]=\"0\" [parentPath]=\"metadata.path\"></vl-element-drop-handle>\n  <ng-container *ngFor=\"let child of metadata.children; let i = index\">\n    <vl-cms-element-renderer [meta]=\"child\"></vl-cms-element-renderer>\n    <vl-element-drop-handle\n      *ngIf=\"dragMode$ | async\"\n      [index]=\"i + 1\"\n      [parentPath]=\"metadata.path\"\n    ></vl-element-drop-handle>\n  </ng-container>\n</ng-container>\n", styles: [":host{display:contents}\n"], dependencies: [{ kind: "directive", type: i4.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i5.ElementRendererComponent, selector: "vl-cms-element-renderer", inputs: ["meta"] }, { kind: "component", type: i6.ElementDropHandleComponent, selector: "vl-element-drop-handle", inputs: ["index", "parentPath"] }, { kind: "pipe", type: i4.AsyncPipe, name: "async" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+ElementChildrenComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.8", type: ElementChildrenComponent, selector: "element-children", inputs: { filter: "filter" }, ngImport: i0, template: "<ng-container *ngIf=\"metadata$ | async as metadata\">\n  <vl-element-drop-handle *ngIf=\"dragMode$ | async\" [index]=\"0\" [parentPath]=\"metadata.path\"></vl-element-drop-handle>\n  <ng-container *ngFor=\"let child of getFilteredChildren(metadata.children); let i = index\">\n    <vl-cms-element-renderer [meta]=\"child\"></vl-cms-element-renderer>\n    <vl-element-drop-handle\n      *ngIf=\"dragMode$ | async\"\n      [index]=\"i + 1\"\n      [parentPath]=\"metadata.path\"\n    ></vl-element-drop-handle>\n  </ng-container>\n</ng-container>\n", styles: [":host{display:contents}\n"], dependencies: [{ kind: "directive", type: i4.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i5.ElementRendererComponent, selector: "vl-cms-element-renderer", inputs: ["meta"] }, { kind: "component", type: i6.ElementDropHandleComponent, selector: "vl-element-drop-handle", inputs: ["index", "parentPath"] }, { kind: "pipe", type: i4.AsyncPipe, name: "async" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: ElementChildrenComponent, decorators: [{
             type: Component,
-            args: [{ selector: 'element-children', changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-container *ngIf=\"metadata$ | async as metadata\">\n  <vl-element-drop-handle *ngIf=\"dragMode$ | async\" [index]=\"0\" [parentPath]=\"metadata.path\"></vl-element-drop-handle>\n  <ng-container *ngFor=\"let child of metadata.children; let i = index\">\n    <vl-cms-element-renderer [meta]=\"child\"></vl-cms-element-renderer>\n    <vl-element-drop-handle\n      *ngIf=\"dragMode$ | async\"\n      [index]=\"i + 1\"\n      [parentPath]=\"metadata.path\"\n    ></vl-element-drop-handle>\n  </ng-container>\n</ng-container>\n", styles: [":host{display:contents}\n"] }]
-        }], ctorParameters: function () { return [{ type: i1.ElementContextService }, { type: i2.RuntimeService }, { type: i3.RuntimeEditorService }, { type: i0.ChangeDetectorRef }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+            args: [{ selector: 'element-children', changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-container *ngIf=\"metadata$ | async as metadata\">\n  <vl-element-drop-handle *ngIf=\"dragMode$ | async\" [index]=\"0\" [parentPath]=\"metadata.path\"></vl-element-drop-handle>\n  <ng-container *ngFor=\"let child of getFilteredChildren(metadata.children); let i = index\">\n    <vl-cms-element-renderer [meta]=\"child\"></vl-cms-element-renderer>\n    <vl-element-drop-handle\n      *ngIf=\"dragMode$ | async\"\n      [index]=\"i + 1\"\n      [parentPath]=\"metadata.path\"\n    ></vl-element-drop-handle>\n  </ng-container>\n</ng-container>\n", styles: [":host{display:contents}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.ElementContextService }, { type: i2.RuntimeService }, { type: i3.RuntimeEditorService }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { filter: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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