@wix/patterns 1.447.0 → 1.448.0

package/src/schema/useEntityPage.ts

@@ -1,7 +1,7 @@
 import { useState } from 'react';
 import type { FieldValues } from 'react-hook-form';
 import type { SchemaSource } from '@wix/bex-core';
-import type { EntityPageState } from '../state';
+import type { EntityPageDeleteAction, EntityPageState } from '../state';
 import {
   useEntityPage as useOpenEntityPage,
   type UseEntityPageParams,
@@ -32,7 +32,8 @@ export function useEntityPage<T, V extends FieldValues = FieldValues>(
   source: SchemaSource<T>,
   options: SchemaEntityPageOptions<T, V>,
 ): EntityPageState<T, V> {
-  const { entityId, fetch, onSave, createLocalItem, ...rest } = options;
+  const { entityId, fetch, onSave, createLocalItem, deleteAction, ...rest } =
+    options;
 
   // The derived read and write need values that change or don't exist yet when
   // the state is created: the state itself (the save merges into the loaded
@@ -46,6 +47,7 @@ export function useEntityPage<T, V extends FieldValues = FieldValues>(
     fetch:
       fetch ?? (() => fetchFromSource(source, page.entityId, createLocalItem)),
     onSave: onSave ?? (() => saveToSource(source, page)),
+    deleteAction: resolveDeleteAction(page, deleteAction),
   } as UseEntityPageParams<T, V>);
 
   page.state = state;
@@ -53,6 +55,17 @@ export function useEntityPage<T, V extends FieldValues = FieldValues>(
   return state;
 }
 
+function resolveDeleteAction<T, V extends FieldValues>(
+  page: PageRef<T, V>,
+  deleteAction: EntityPageDeleteAction<T> | undefined,
+): EntityPageDeleteAction<T> | undefined {
+  if (!deleteAction || !page.entityId) {
+    return undefined;
+  }
+
+  return deleteAction;
+}
+
 interface PageRef<T, V extends FieldValues> {
   entityId?: string;
   state?: EntityPageState<T, V>;
@@ -99,11 +112,13 @@ async function saveToSource<T, V extends FieldValues>(
     throw new Error(`The source has no entity "${entityId}" to update`);
   }
 
+  const updatedEntity = { ...entity, ...values } as T;
+
   return {
-    updatedEntity: await required(
-      backend.update,
-      'updating',
-    )({ ...entity, ...values } as T),
+    updatedEntity: await required(backend.update, 'updating')(updatedEntity, {
+      previousItem: entity,
+      changedFieldIds: changedFieldIds(entity, updatedEntity, state!.form),
+    }),
   };
 }
 
@@ -113,3 +128,24 @@ function required<F>(fn: F | undefined, action: string): F {
   }
   return fn;
 }
+
+function changedFieldIds<T, V extends FieldValues>(
+  previousItem: T,
+  updatedItem: T,
+  form: EntityPageState<T, V>['form'],
+): string[] {
+  const dirtyFields = form.formState.dirtyFields as Record<string, unknown>;
+  const dirtyFieldIds = Object.entries(dirtyFields)
+    .filter(([, value]) => Boolean(value))
+    .map(([fieldId]) => fieldId);
+
+  const previousRecord = previousItem as Record<string, unknown>;
+  const updatedRecord = updatedItem as Record<string, unknown>;
+  const changedByValue = Array.from(
+    new Set([...Object.keys(previousRecord), ...Object.keys(updatedRecord)]),
+  ).filter(
+    (fieldId) => !Object.is(previousRecord[fieldId], updatedRecord[fieldId]),
+  );
+
+  return Array.from(new Set([...dirtyFieldIds, ...changedByValue]));
+}

package/src/state/CollectionPage/CollectionPageHeader.st.css.ts

@@ -5,7 +5,7 @@ import { classesRuntime, statesRuntime } from "../../stylable-esm-runtime.js";
 
 
 
-var _namespace_ = "CollectionPageHeader4273170589";
+var _namespace_ = "CollectionPageHeader2816488786";
 var _style_ = classesRuntime.bind(null, _namespace_);
 
 export var cssStates = statesRuntime.bind(null, _namespace_);
@@ -13,7 +13,7 @@ export var style = _style_;
 export var st: import("@stylable/runtime").STFunction = _style_;
 
 export var namespace = _namespace_;
-export var classes = {"root":"CollectionPageHeader4273170589__root"};
+export var classes = {"root":"CollectionPageHeader2816488786__root"};
 export var keyframes = {}; 
 export var layers = {};
 export var containers = {};

package/src/state/EditableTable/CellValueState.ts

@@ -300,7 +300,10 @@ export class CellValueState<T, F extends FiltersMap> {
    * read-only cells protected regardless of entry point.
    */
   applyBulkValues(changes: { rowKey: string; columnId: string; value: any }[]) {
-    const rowItems = new Map<string, T>();
+    const rowUpdates = new Map<
+      string,
+      { item: T; changedFieldIds: Set<string> }
+    >();
 
     for (const { rowKey, columnId, value } of changes) {
       const column = this._parent._columnMap.get(columnId);
@@ -339,10 +342,17 @@ export class CellValueState<T, F extends FiltersMap> {
           }
           continue;
         }
-        const currentItem =
-          rowItems.get(rowKey) ??
-          this._consumeRowDrafts(rowKey, keyedItem.item);
-        rowItems.set(rowKey, column.setValue(currentItem, value));
+        let rowUpdate = rowUpdates.get(rowKey);
+        if (!rowUpdate) {
+          const consumed = this._consumeRowDrafts(rowKey, keyedItem.item);
+          rowUpdate = {
+            item: consumed.item,
+            changedFieldIds: new Set(consumed.changedFieldIds),
+          };
+          rowUpdates.set(rowKey, rowUpdate);
+        }
+        rowUpdate.item = column.setValue(rowUpdate.item, value);
+        rowUpdate.changedFieldIds.add(column.id);
       } else if (pendingKey) {
         this._pendingCells.set(pendingKey, {
           value,
@@ -351,7 +361,11 @@ export class CellValueState<T, F extends FiltersMap> {
       }
     }
 
-    this._parent.mutation.updateItems(Array.from(rowItems.values()));
+    const updates = Array.from(rowUpdates.values());
+    this._parent.mutation.updateItems(
+      updates.map(({ item }) => item),
+      updates.map(({ changedFieldIds }) => Array.from(changedFieldIds)),
+    );
   }
 
   private _applyValue(rowKey: string, columnId: string, value: any) {
@@ -393,26 +407,32 @@ export class CellValueState<T, F extends FiltersMap> {
       }
     }
 
-    const items: T[] = [];
+    const updates: { item: T; changedFieldIds: string[] }[] = [];
     for (const rowKey of rowKeys) {
       const keyedItem = this._parent._getKeyedItem(rowKey);
       if (!keyedItem) {
         this._dropRowDrafts(rowKey);
       } else if (this._parent.mutation.isLocalNewRow(rowKey)) {
-        this._parent.mutation.commitNewRow(
-          rowKey,
-          this._consumeRowDrafts(rowKey, keyedItem.item),
-        );
+        const consumed = this._consumeRowDrafts(rowKey, keyedItem.item);
+        this._parent.mutation.commitNewRow(rowKey, consumed.item);
       } else {
-        items.push(this._consumeRowDrafts(rowKey, keyedItem.item));
+        const consumed = this._consumeRowDrafts(rowKey, keyedItem.item);
+        updates.push(consumed);
       }
     }
-    if (items.length > 0) {
-      this._parent.mutation.updateItems(items);
+    if (updates.length > 0) {
+      this._parent.mutation.updateItems(
+        updates.map(({ item }) => item),
+        updates.map(({ changedFieldIds }) => changedFieldIds),
+      );
     }
   }
 
-  private _consumeRowDrafts(rowKey: string, item: T): T {
+  private _consumeRowDrafts(
+    rowKey: string,
+    item: T,
+  ): { item: T; changedFieldIds: string[] } {
+    const changedFieldIds = new Set<string>();
     for (const [key, entry] of this._draftCells) {
       if (entry.rowKey !== rowKey) {
         continue;
@@ -420,10 +440,11 @@ export class CellValueState<T, F extends FiltersMap> {
       const column = this._parent._columnMap.get(entry.columnId);
       if (column?.setValue) {
         item = column.setValue(item, entry.value);
+        changedFieldIds.add(column.id);
       }
       this._draftCells.delete(key);
     }
-    return item;
+    return { item, changedFieldIds: Array.from(changedFieldIds) };
   }
 
   /** Drop a row's draft entries without saving (the row no longer exists). */

package/src/state/EditableTable/MutationState.ts

@@ -1,6 +1,7 @@
 import { action, makeObservable, observable, runInAction } from 'mobx';
 import type {
   CollectionOptimisticActions,
+  CollectionUpdateContext,
   CollectionState,
   FiltersMap,
   KeyedItem,
@@ -11,7 +12,10 @@ export interface EditableTableMutationHandlers<T> {
   /** Factory to create a new empty item with a fresh ID */
   createItem: () => T;
   /** Submit updated items to the server */
-  submitUpdate: (items: T[]) => Promise<T[] | void>;
+  submitUpdate: (
+    items: T[],
+    contexts?: CollectionUpdateContext<T>[],
+  ) => Promise<T[] | void>;
   /** Submit newly created items to the server */
   submitCreate: (items: T[]) => Promise<T[] | void>;
   /** Submit item deletions to the server */
@@ -239,14 +243,18 @@ export class MutationState<T, F extends FiltersMap> {
     });
   }
 
-  updateItems(updatedItems: T[]) {
+  updateItems(
+    updatedItems: T[],
+    changedFieldIdsByItem?: string[][],
+  ) {
     const t = this._parent.collection.translate;
     if (updatedItems.length === 0) {
       return;
     }
+    const contexts = this._updateContexts(updatedItems, changedFieldIdsByItem);
     this._optimisticActions.updateMany(updatedItems, {
       keepPosition: true,
-      submit: this._handlers.submitUpdate,
+      submit: (items) => this._submitUpdate(items, updatedItems, contexts),
       successToast: t('cairo.editableTable.updateItem.success.toast', {
         count: updatedItems.length,
       }),
@@ -260,6 +268,35 @@ export class MutationState<T, F extends FiltersMap> {
     });
   }
 
+  private _submitUpdate(
+    items: T[],
+    updatedItems: T[],
+    contexts: CollectionUpdateContext<T>[],
+  ) {
+    const sameItems =
+      items.length === updatedItems.length &&
+      items.every((item, index) => item === updatedItems[index]);
+
+    return this._handlers.submitUpdate(items, sameItems ? contexts : undefined);
+  }
+
+  private _updateContexts(
+    updatedItems: T[],
+    changedFieldIdsByItem?: string[][],
+  ): CollectionUpdateContext<T>[] {
+    return updatedItems.map((item, index) => {
+      const key = this._parent.collection.itemKey(item);
+      const previousItem =
+        this._parent.collection.result.get(key)?.item ?? item;
+      return {
+        previousItem,
+        changedFieldIds:
+          changedFieldIdsByItem?.[index] ??
+          changedFieldIdsFromItems(previousItem, item),
+      };
+    });
+  }
+
   /**
    * Nearest row above `rowKey` that a create can anchor on: a server row
    * that is not a draft and not itself a created row still living as an
@@ -336,3 +373,21 @@ export class MutationState<T, F extends FiltersMap> {
     return createdItems;
   };
 }
+
+const changedFieldIdsFromItems = <T>(
+  previousItem: T,
+  updatedItem: T,
+): string[] => {
+  if (!isRecord(previousItem) || !isRecord(updatedItem)) {
+    return [];
+  }
+
+  return Array.from(
+    new Set([...Object.keys(previousItem), ...Object.keys(updatedItem)]),
+  ).filter(
+    (fieldId) => !Object.is(previousItem[fieldId], updatedItem[fieldId]),
+  );
+};
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null;

package/src/state/EntityPage/EntityPageDeleteActionState.ts

@@ -0,0 +1,228 @@
+import { TaskState } from '@wix/bex-core';
+import type {
+  LoadedSchema,
+  SchemaSource,
+  ToastConfig,
+  WixPatternsContainer,
+} from '@wix/bex-core';
+import { computed, makeObservable } from 'mobx';
+
+type DeleteErrorToast = (
+  err: unknown,
+  params: { retry: () => void },
+) =>
+  | {
+      message?: string;
+      tryAgain?: boolean;
+      action?: { text: string; onClick: () => void };
+    }
+  | string;
+
+export interface EntityPageDeleteActionConfig<T> {
+  enabled?: boolean;
+  onDelete?: (entity: T) => Promise<void>;
+  successToast?: Pick<ToastConfig, 'message'> | string;
+  errorToast?: DeleteErrorToast;
+  itemName?: (entity: T) => string;
+}
+
+export type EntityPageDeleteAction<T> =
+  | boolean
+  | EntityPageDeleteActionConfig<T>;
+
+export interface EntityPageDeleteActionStateParams<T> {
+  container: WixPatternsContainer;
+  deleteAction?: EntityPageDeleteAction<T>;
+  schemaSource?: SchemaSource<T>;
+  getEntity: () => T | null;
+  getLoadedSchema: () => LoadedSchema<T> | null;
+  transformEntityToCollectionItem: (entity: T) => any;
+  onDeleted: (deletedCollectionItem: any) => void;
+  emitDelete: () => void;
+  emitDeleteError: (err: unknown) => void;
+}
+
+export class EntityPageDeleteActionState<T> {
+  readonly container: WixPatternsContainer;
+  readonly deleteAction?: EntityPageDeleteAction<T>;
+  readonly schemaSource?: SchemaSource<T>;
+  readonly getEntity: () => T | null;
+  readonly getLoadedSchema: () => LoadedSchema<T> | null;
+  readonly transformEntityToCollectionItem: (entity: T) => any;
+  readonly onDeleted: (deletedCollectionItem: any) => void;
+  readonly emitDelete: () => void;
+  readonly emitDeleteError: (err: unknown) => void;
+
+  readonly task = new TaskState<void>();
+
+  constructor(params: EntityPageDeleteActionStateParams<T>) {
+    this.container = params.container;
+    this.deleteAction = params.deleteAction;
+    this.schemaSource = params.schemaSource;
+    this.getEntity = params.getEntity;
+    this.getLoadedSchema = params.getLoadedSchema;
+    this.transformEntityToCollectionItem =
+      params.transformEntityToCollectionItem;
+    this.onDeleted = params.onDeleted;
+    this.emitDelete = params.emitDelete;
+    this.emitDeleteError = params.emitDeleteError;
+
+    makeObservable(this, {
+      canShow: computed,
+      disabledReason: computed,
+    });
+  }
+
+  private get config(): EntityPageDeleteActionConfig<T> | null {
+    if (!this.deleteAction) {
+      return null;
+    }
+
+    return typeof this.deleteAction === 'boolean' ? {} : this.deleteAction;
+  }
+
+  private get isEnabled() {
+    return this.config?.enabled !== false;
+  }
+
+  private getDeleteHandler(): ((entity: T) => Promise<void>) | undefined {
+    const config = this.config;
+    if (!config || !this.isEnabled) {
+      return undefined;
+    }
+
+    if (config.onDelete) {
+      return config.onDelete;
+    }
+
+    const backendDelete = this.getLoadedSchema()?.backend.delete;
+    if (this.schemaSource && backendDelete) {
+      return (entity) => backendDelete(this.schemaSource!.itemKey(entity));
+    }
+
+    return undefined;
+  }
+
+  get canShow() {
+    const itemPermissions = this.getLoadedSchema()?.schema.itemPermissions;
+    return (
+      !!this.getEntity() &&
+      !!this.config &&
+      this.isEnabled &&
+      !!this.getDeleteHandler() &&
+      (itemPermissions?.deleteItem ?? true)
+    );
+  }
+
+  get disabledReason() {
+    const entity = this.getEntity();
+    const itemPermissions = this.getLoadedSchema()?.schema.itemPermissions;
+    const disabledResult =
+      entity && itemPermissions?.isRemoveItemDisabled
+        ? itemPermissions.isRemoveItemDisabled(entity)
+        : undefined;
+
+    if (!disabledResult?.disabled) {
+      return undefined;
+    }
+
+    return disabledResult.reason ?? this.container.translate('cairo.disabled');
+  }
+
+  getItemName(entity: T) {
+    const itemName =
+      this.config?.itemName?.(entity) ?? this.schemaSource?.itemName(entity);
+
+    return (
+      itemName ||
+      this.container.translate('cairo.entity.item', {
+        num: 1,
+      })
+    );
+  }
+
+  private showSuccessToast(deletedEntity: T) {
+    const successToast = this.config?.successToast;
+    const message =
+      typeof successToast === 'string' ? successToast : successToast?.message;
+
+    this.container.showToast?.({
+      type: 'SUCCESS',
+      biName: 'cairo-entity-page-delete-success-toast',
+      message:
+        message ??
+        this.container.translate('cairo.deleteSuccess', {
+          itemName: this.getItemName(deletedEntity),
+        }),
+    });
+  }
+
+  private showErrorToast(err: unknown) {
+    const errorToast = this.config?.errorToast?.(err, {
+      retry: () => this.deleteEntity(),
+    });
+    const message =
+      typeof errorToast === 'string' ? errorToast : errorToast?.message;
+    const showTryAgain =
+      typeof errorToast === 'string' ? true : errorToast?.tryAgain !== false;
+    const action =
+      typeof errorToast === 'string' ? undefined : errorToast?.action;
+
+    this.container.showToast?.({
+      type: 'ERROR',
+      biName: 'cairo-entity-page-delete-error-toast',
+      message:
+        message ?? this.container.translate('cairo.technical.error.text'),
+      action:
+        action || showTryAgain
+          ? {
+              uiType: 'LINK',
+              text:
+                action?.text ?? this.container.translate('cairo.toast.retry'),
+              onClick: () => {
+                if (action?.onClick) {
+                  action.onClick();
+                } else {
+                  this.deleteEntity();
+                }
+              },
+              removeToastOnClick: true,
+            }
+          : undefined,
+    });
+  }
+
+  async deleteEntity() {
+    if (this.task.status.isLoading || !this.canShow || this.disabledReason) {
+      return;
+    }
+
+    const entity = this.getEntity();
+    const deleteHandler = this.getDeleteHandler();
+    if (!entity || !deleteHandler) {
+      return;
+    }
+
+    this.emitDelete();
+
+    let caughtError: unknown;
+    await this.task.run(
+      async () => {
+        await deleteHandler(entity);
+      },
+      (err) => {
+        caughtError = err;
+      },
+    );
+
+    if (caughtError) {
+      this.showErrorToast(caughtError);
+      this.container.errorMonitor.captureException(caughtError);
+      this.emitDeleteError(caughtError);
+      throw caughtError;
+    }
+
+    this.showSuccessToast(entity);
+    this.onDeleted(this.transformEntityToCollectionItem(entity));
+  }
+}

package/src/state/EntityPage/EntityPageState.ts

@@ -7,6 +7,7 @@ import {
   SchemaSource,
   Schema,
 } from '@wix/bex-core';
+import type { LoadedSchema } from '@wix/bex-core';
 import { action, computed, makeObservable, observable } from 'mobx';
 import type { PatternsFieldsAppContainer } from '@wix/patterns-fields/providers';
 import { fieldsContainerOf } from '../../model/schemaFieldsContainer';
@@ -16,6 +17,10 @@ import { EventEmitter, TypedEmitter } from '@wix/bex-core/events';
 import { WixPatternsRouterState } from '../WixPatternsRouterState';
 import type { SidePanelsState } from '../SidePanelsState';
 import type { CustomColumnsEntityPageState } from '../CustomColumnsEntityPageState';
+import {
+  EntityPageDeleteAction,
+  EntityPageDeleteActionState,
+} from './EntityPageDeleteActionState';
 
 type OnSaveParams = {
   widgetsFormData: { [key: string]: any };
@@ -58,6 +63,13 @@ interface EntityPageStateParamsBase<T, V extends FieldValues = FieldValues> {
       }
     | string;
 
+  /**
+   * Enables deleting the loaded entity from the entity page. Pass `true` for a
+   * schema-backed page to use the source backend, or an object to customize the
+   * action and to provide a delete handler for manually wired pages.
+   */
+  deleteAction?: EntityPageDeleteAction<T>;
+
   /**
    * An optional function to transform the updated entity data before it is passed to the collection page.
    * @param entity the updated entity.
@@ -136,6 +148,7 @@ export class EntityPageState<T, V extends FieldValues = FieldValues>
 
   _entity: T | null = null;
   _schema: Schema | null = null;
+  _loadedSchema: LoadedSchema<T> | null = null;
   private readonly _parentPageId?: string;
   private readonly _parentPath?: string;
   private readonly _parentReferrer?: string;
@@ -175,10 +188,13 @@ export class EntityPageState<T, V extends FieldValues = FieldValues>
   _routerState: WixPatternsRouterState | null = null;
 
   readonly formPage: FormPageState<V>;
+  readonly deleteActionState: EntityPageDeleteActionState<T>;
 
   readonly events = new EventEmitter() as TypedEmitter<{
     save: () => void;
     saveError: (err: unknown) => void;
+    delete: () => void;
+    deleteError: (err: unknown) => void;
   }>;
 
   constructor(params: EntityPageStateParams<T, V>) {
@@ -195,6 +211,19 @@ export class EntityPageState<T, V extends FieldValues = FieldValues>
     this.schemaSource = params.schemaSource;
 
     this.container = params.container;
+    this.deleteActionState = new EntityPageDeleteActionState<T>({
+      container: this.container,
+      deleteAction: params.deleteAction,
+      schemaSource: this.schemaSource,
+      getEntity: () => this.entity,
+      getLoadedSchema: () => this.loadedSchema,
+      transformEntityToCollectionItem: this.transformEntityToCollectionItem,
+      onDeleted: action((deletedCollectionItem) =>
+        this.handleEntityDeleted(deletedCollectionItem),
+      ),
+      emitDelete: () => this.events.emit('delete'),
+      emitDeleteError: (err) => this.events.emit('deleteError', err),
+    });
 
     this._routerState = params.routerState ?? null;
 
@@ -220,6 +249,8 @@ export class EntityPageState<T, V extends FieldValues = FieldValues>
       setEntity: action,
       _schema: observable.ref,
       setSchema: action,
+      _loadedSchema: observable.ref,
+      setLoadedSchema: action,
       customColumnsState: observable.ref,
       isFormDirty: computed,
       _withinRouter: computed,
@@ -267,6 +298,7 @@ export class EntityPageState<T, V extends FieldValues = FieldValues>
       ]);
 
       this.setEntity(data.entity ?? null);
+      this.setLoadedSchema(loadedSchema ?? null);
       // Don't overwrite a schema something already set. A fields card mirrors the
       // schema its field mutations merge into, and `loadSchema` is memoized — so
       // setting it here again would put the pre-mutation fields map back and drop
@@ -303,6 +335,14 @@ export class EntityPageState<T, V extends FieldValues = FieldValues>
     return this._schema;
   }
 
+  setLoadedSchema(loadedSchema: LoadedSchema<T> | null) {
+    this._loadedSchema = loadedSchema;
+  }
+
+  get loadedSchema(): LoadedSchema<T> | null {
+    return this._loadedSchema;
+  }
+
   get isFetching() {
     return this.formPage.isFetching;
   }
@@ -338,8 +378,10 @@ export class EntityPageState<T, V extends FieldValues = FieldValues>
 
   navigateToParent(updatedEntity?: any) {
     const entityStringKey = this._entity ? '_updatedEntity' : '_createdEntity';
-    const entityObject = { [entityStringKey]: updatedEntity };
+    this.navigateToParentWithState({ [entityStringKey]: updatedEntity });
+  }
 
+  navigateToParentWithState(entityObject: Record<string, unknown>) {
     if (this._withinRouter) {
       this._routerState!.navigate(this._parentPath!, { state: entityObject });
     } else {
@@ -407,6 +449,11 @@ export class EntityPageState<T, V extends FieldValues = FieldValues>
     });
   }
 
+  private handleEntityDeleted(deletedCollectionItem: any) {
+    this.isSubmitSuccessful = true;
+    this.navigateToParentWithState({ _deletedEntity: deletedCollectionItem });
+  }
+
   async handleSubmit(e?: React.BaseSyntheticEvent) {
     if (this.formPage.submitTask.status.isLoading) {
       return;

package/src/state/EntityPage/index.ts

@@ -1,3 +1,4 @@
 export * from './EntityPageState';
+export * from './EntityPageDeleteActionState';
 export * from './useEntityPageHeader';
 export * from './useEntityPageContent';

package/src/state/FormPage/FormPageHeader.st.css.ts

@@ -5,7 +5,7 @@ import { classesRuntime, statesRuntime } from "../../stylable-esm-runtime.js";
 
 
 
-var _namespace_ = "FormPageHeader3029584173";
+var _namespace_ = "FormPageHeader3751915783";
 var _style_ = classesRuntime.bind(null, _namespace_);
 
 export var cssStates = statesRuntime.bind(null, _namespace_);
@@ -13,7 +13,7 @@ export var style = _style_;
 export var st: import("@stylable/runtime").STFunction = _style_;
 
 export var namespace = _namespace_;
-export var classes = {"root":"FormPageHeader3029584173__root"};
+export var classes = {"root":"FormPageHeader3751915783__root"};
 export var keyframes = {}; 
 export var layers = {};
 export var containers = {};

package/src/state/WixPatternsRouterState.ts

@@ -12,6 +12,7 @@ interface WixPatternsRouterStateParams {
 export type RouteState = {
   _createdEntity?: any;
   _updatedEntity?: any;
+  _deletedEntity?: any;
   _chosenEntity?: any;
 } | null;