dotvvm-types 4.3.5 → 5.0.0-preview01-final

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dotvvm-types",
-  "version": "4.3.5",
+  "version": "5.0.0-preview01-final",
   "description": "MVVM framework for ASP.NET",
   "types": "./types/index.d.ts",
   "repository": {

package/types/index.d.ts

@@ -212,6 +212,8 @@ declare module "validation/error" {
 }
 declare module "state-manager" {
     import { DotvvmEvent } from "events";
+    import { ValidationError } from "validation/error";
+    import { errorsSymbol } from "validation/common";
     export const currentStateSymbol: unique symbol;
     export const notifySymbol: unique symbol;
     export const lastSetErrorSymbol: unique symbol;
@@ -232,7 +234,7 @@ declare module "state-manager" {
     export class StateManager<TViewModel extends {
         $type?: TypeDefinition;
     }> implements DotvvmStateContainer<TViewModel> {
-        stateUpdateEvent: DotvvmEvent<DeepReadonly<TViewModel>>;
+        stateUpdateEvent?: DotvvmEvent<DeepReadonly<TViewModel>> | undefined;
         /** The knockout observable containing the root objects, equivalent to `dotvvm.viewModels.root.viewModel` */
         readonly stateObservable: DeepKnockoutObservable<TViewModel>;
         private _state;
@@ -242,7 +244,7 @@ declare module "state-manager" {
         /** Indicates whether there is a pending update of the knockout observables. */
         get isDirty(): boolean;
         private _currentFrameNumber;
-        constructor(initialState: DeepReadonly<TViewModel>, stateUpdateEvent: DotvvmEvent<DeepReadonly<TViewModel>>);
+        constructor(initialState: DeepReadonly<TViewModel>, stateUpdateEvent?: DotvvmEvent<DeepReadonly<TViewModel>> | undefined);
         private dispatchUpdate;
         /** Performs a synchronous update of knockout observables with the data currently stored in `state`.
          *  Consequently, if ko.options.deferUpdates is false (default), the UI will be updated immediately.
@@ -268,12 +270,25 @@ declare module "state-manager" {
         /** @deprecated Use updateState method instead */
         update: UpdateDispatcher<TViewModel>;
     }
+    class FakeObservableObject<T extends object> implements UpdatableObjectExtensions<T> {
+        [currentStateSymbol]: T;
+        [errorsSymbol]: Array<ValidationError>;
+        [updateSymbol]: UpdateDispatcher<T>;
+        [notifySymbol](newValue: T): void;
+        [internalPropCache]: {
+            [name: string]: (KnockoutObservable<any> & UpdatableObjectExtensions<any>) | null;
+        };
+        [updatePropertySymbol](propName: keyof DeepReadonly<T>, valUpdate: StateUpdate<any>): void;
+        constructor(initialValue: T, getter: () => DeepReadonly<T> | undefined, updater: UpdateDispatcher<T>, typeId: TypeDefinition, typeInfo: ObjectTypeMetadata | DynamicTypeMetadata | undefined, additionalProperties: string[]);
+    }
     export function isDotvvmObservable(obj: any): obj is DotvvmObservable<any>;
+    export function isFakeObservableObject(obj: any): obj is FakeObservableObject<any>;
     /**
      * Recursively unwraps knockout observables from the object / array hierarchy. When nothing needs to be unwrapped, the original object is returned.
      * @param allowStateUnwrap Allows accessing [currentStateSymbol], which makes it faster, but doesn't register in the knockout dependency tracker
+     * @param preferStateAccess Also allows accessing observable.state, which also doesn't register in the knockout dependency tracker, but returns an realtime updated value directly from dotvvm.state
     */
-    export function unmapKnockoutObservables(viewModel: any, allowStateUnwrap?: boolean): any;
+    export function unmapKnockoutObservables(viewModel: any, allowStateUnwrap?: boolean, preferStateAccess?: boolean): any;
 }
 declare module "serialization/deserialize" {
     export function deserialize(viewModel: any, target?: any, deserializeAll?: boolean): any;
@@ -509,6 +524,21 @@ declare module "binding-handlers/modal-dialog" {
     };
     export default _default_12;
 }
+declare module "binding-handlers/appendable-data-pager" {
+    type AppendableDataPagerBinding = {
+        autoLoadWhenInViewport: boolean;
+        loadNextPage: () => Promise<any>;
+        dataSet: any;
+    };
+    const _default_13: {
+        'dotvvm-appendable-data-pager': {
+            init: (element: HTMLInputElement, valueAccessor: () => AppendableDataPagerBinding, allBindings?: any, viewModel?: any, bindingContext?: KnockoutBindingContext) => {
+                controlsDescendantBindings: boolean;
+            };
+        };
+    };
+    export default _default_13;
+}
 declare module "binding-handlers/all-handlers" {
     type KnockoutHandlerDictionary = {
         [name: string]: KnockoutBindingHandler;
@@ -747,8 +777,8 @@ declare module "spa/spa" {
     export function handleSpaNavigationCore(url: string | null, sender?: HTMLElement, handlePageNavigating?: (url: string) => void): Promise<DotvvmNavigationEventArgs>;
 }
 declare module "binding-handlers/register" {
-    const _default_13: () => void;
-    export default _default_13;
+    const _default_14: () => void;
+    export default _default_14;
 }
 declare module "postback/staticCommand" {
     export function resolveRelativeValidationPaths(paths: string[] | null | undefined, context: KnockoutBindingContext | undefined): (string | null)[] | undefined;
@@ -824,7 +854,7 @@ declare module "translations/translations" {
     import * as dictionary from "translations/dictionaryHelper";
     import * as string from "translations/stringHelper";
     import * as dateTime from "translations/dateTimeHelper";
-    const _default_14: Readonly<{
+    const _default_15: Readonly<{
         array: typeof array;
         dictionary: typeof dictionary;
         string: typeof string;
@@ -834,7 +864,90 @@ declare module "translations/translations" {
             toInt(value: any, type: string): number | null;
         };
     }>;
-    export default _default_14;
+    export default _default_15;
+}
+declare module "dataset/loader" {
+    type GridViewDataSet = {
+        PagingOptions: object;
+        SortingOptions: object;
+        FilteringOptions: object;
+        Items: any[];
+        IsRefreshRequired?: boolean;
+    };
+    type GridViewDataSetOptions = {
+        PagingOptions: object;
+        SortingOptions: object;
+        FilteringOptions: object;
+    };
+    type GridViewDataSetResult = {
+        Items: any[];
+        PagingOptions: object;
+        SortingOptions: object;
+        FilteringOptions: object;
+    };
+    export function getOptions(dataSetObservable: DotvvmObservable<GridViewDataSet>): GridViewDataSetOptions;
+    export function loadDataSet(dataSetObservable: DotvvmObservable<GridViewDataSet>, transformOptions: (options: GridViewDataSetOptions) => void, loadData: (options: GridViewDataSetOptions) => Promise<DotvvmAfterPostBackEventArgs>, postProcessor?: (dataSet: DotvvmObservable<GridViewDataSet>, result: GridViewDataSetResult) => void): Promise<void>;
+    export const postProcessors: {
+        replace(dataSet: DotvvmObservable<GridViewDataSet>, result: GridViewDataSetResult): void;
+        append(dataSet: DotvvmObservable<GridViewDataSet>, result: GridViewDataSetResult): void;
+    };
+}
+declare module "dataset/translations" {
+    import { getOptions } from "dataset/loader";
+    type PagingOptions = {
+        PageIndex: number;
+        PagesCount: number;
+    };
+    type NextTokenPagingOptions = {
+        CurrentToken: string | null;
+        NextPageToken: string | null;
+    };
+    type NextTokenHistoryPagingOptions = {
+        PageIndex: number;
+        TokenHistory: (string | null)[];
+    };
+    type SortingOptions = {
+        SortExpression: string | null;
+        SortDescending: boolean;
+    };
+    type MultiCriteriaSortingOptions = {
+        Criteria: SortCriterion[];
+        MaxSortCriteriaCount: number;
+    };
+    type SortCriterion = {
+        SortExpression: string;
+        SortDescending: boolean;
+    };
+    export const translations: {
+        getOptions: typeof getOptions;
+        PagingOptions: {
+            goToFirstPage(options: PagingOptions): void;
+            goToLastPage(options: PagingOptions): void;
+            goToNextPage(options: PagingOptions): void;
+            goToPreviousPage(options: PagingOptions): void;
+            goToPage(options: PagingOptions, pageIndex: number): void;
+        };
+        NextTokenPagingOptions: {
+            goToFirstPage(options: NextTokenPagingOptions): void;
+            goToNextPage(options: NextTokenPagingOptions): void;
+        };
+        NextTokenHistoryPagingOptions: {
+            goToFirstPage(options: NextTokenHistoryPagingOptions): void;
+            goToNextPage(options: NextTokenHistoryPagingOptions): void;
+            goToPreviousPage(options: NextTokenHistoryPagingOptions): void;
+            goToPage(options: NextTokenHistoryPagingOptions, pageIndex: number): void;
+        };
+        SortingOptions: {
+            setSortExpression(options: SortingOptions, sortExpression: string): void;
+            isColumnSortedAscending(options: SortingOptions, sortExpression: string): boolean;
+            isColumnSortedDescending(options: SortingOptions, sortExpression: string): boolean;
+        };
+        MultiCriteriaSortingOptions: {
+            setSortExpression(options: MultiCriteriaSortingOptions, sortExpression: string): void;
+            isColumnSortedAscending(options: MultiCriteriaSortingOptions, sortExpression: string): boolean;
+            isColumnSortedDescending(options: MultiCriteriaSortingOptions, sortExpression: string): boolean;
+        };
+    };
 }
 declare module "dotvvm-root" {
     import { getCulture } from "dotvvm-base";
@@ -860,6 +973,7 @@ declare module "dotvvm-root" {
     import { logError, logWarning, logInfo, logInfoVerbose, logPostBackScriptError, setLogger } from "utils/logging";
     import * as metadataHelper from "metadata/metadataHelper";
     import { StateManager } from "state-manager";
+    import { loadDataSet } from "dataset/loader";
     function init(culture: string): void;
     const dotvvmExports: {
         getCulture: typeof getCulture;
@@ -953,6 +1067,125 @@ declare module "dotvvm-root" {
             compressPOST: boolean;
         };
         translations: any;
+        dataSet: {
+            loadDataSet: typeof loadDataSet;
+            postProcessors: {
+                replace(dataSet: DotvvmObservable<{
+                    PagingOptions: object;
+                    SortingOptions: object;
+                    FilteringOptions: object;
+                    Items: any[];
+                    IsRefreshRequired?: boolean | undefined;
+                }>, result: {
+                    Items: any[];
+                    PagingOptions: object;
+                    SortingOptions: object;
+                    FilteringOptions: object;
+                }): void;
+                append(dataSet: DotvvmObservable<{
+                    PagingOptions: object;
+                    SortingOptions: object;
+                    FilteringOptions: object;
+                    Items: any[];
+                    IsRefreshRequired?: boolean | undefined;
+                }>, result: {
+                    Items: any[];
+                    PagingOptions: object;
+                    SortingOptions: object;
+                    FilteringOptions: object;
+                }): void;
+            };
+            translations: {
+                getOptions: typeof import("dataset/loader").getOptions;
+                PagingOptions: {
+                    goToFirstPage(options: {
+                        PageIndex: number;
+                        PagesCount: number;
+                    }): void;
+                    goToLastPage(options: {
+                        PageIndex: number;
+                        PagesCount: number;
+                    }): void;
+                    goToNextPage(options: {
+                        PageIndex: number;
+                        PagesCount: number;
+                    }): void;
+                    goToPreviousPage(options: {
+                        PageIndex: number;
+                        PagesCount: number;
+                    }): void;
+                    goToPage(options: {
+                        PageIndex: number;
+                        PagesCount: number;
+                    }, pageIndex: number): void;
+                };
+                NextTokenPagingOptions: {
+                    goToFirstPage(options: {
+                        CurrentToken: string | null;
+                        NextPageToken: string | null;
+                    }): void;
+                    goToNextPage(options: {
+                        CurrentToken: string | null;
+                        NextPageToken: string | null;
+                    }): void;
+                };
+                NextTokenHistoryPagingOptions: {
+                    goToFirstPage(options: {
+                        PageIndex: number;
+                        TokenHistory: (string | null)[];
+                    }): void;
+                    goToNextPage(options: {
+                        PageIndex: number;
+                        TokenHistory: (string | null)[];
+                    }): void;
+                    goToPreviousPage(options: {
+                        PageIndex: number;
+                        TokenHistory: (string | null)[];
+                    }): void;
+                    goToPage(options: {
+                        PageIndex: number;
+                        TokenHistory: (string | null)[];
+                    }, pageIndex: number): void;
+                };
+                SortingOptions: {
+                    setSortExpression(options: {
+                        SortExpression: string | null;
+                        SortDescending: boolean;
+                    }, sortExpression: string): void;
+                    isColumnSortedAscending(options: {
+                        SortExpression: string | null;
+                        SortDescending: boolean;
+                    }, sortExpression: string): boolean;
+                    isColumnSortedDescending(options: {
+                        SortExpression: string | null;
+                        SortDescending: boolean;
+                    }, sortExpression: string): boolean;
+                };
+                MultiCriteriaSortingOptions: {
+                    setSortExpression(options: {
+                        Criteria: {
+                            SortExpression: string;
+                            SortDescending: boolean;
+                        }[];
+                        MaxSortCriteriaCount: number;
+                    }, sortExpression: string): void;
+                    isColumnSortedAscending(options: {
+                        Criteria: {
+                            SortExpression: string;
+                            SortDescending: boolean;
+                        }[];
+                        MaxSortCriteriaCount: number;
+                    }, sortExpression: string): boolean;
+                    isColumnSortedDescending(options: {
+                        Criteria: {
+                            SortExpression: string;
+                            SortDescending: boolean;
+                        }[];
+                        MaxSortCriteriaCount: number;
+                    }, sortExpression: string): boolean;
+                };
+            };
+        };
         StateManager: typeof StateManager;
         DotvvmEvent: typeof events.DotvvmEvent;
     };