dotvvm-types 4.3.0-preview03-final → 4.3.0-preview05-final

package/package.json

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

package/types/index.d.ts

@@ -5,8 +5,7 @@ declare module "shared-classes" {
         constructor(reason: DotvvmPostbackErrorReason);
         toString(): string;
     }
-    export class CoerceError implements CoerceErrorType {
-        message: string;
+    export class CoerceError extends Error implements CoerceErrorType {
         path: string;
         isError: true;
         wasCoerced: false;
@@ -19,6 +18,20 @@ declare module "shared-classes" {
 declare module "utils/logging" {
     type LogLevel = "normal" | "verbose";
     export const level: LogLevel;
+    type ConsoleLogLevel = "warn" | "log" | "error" | "trace";
+    let logger: (level: ConsoleLogLevel, area: DotvvmLoggingArea, ...args: any) => void;
+    /**
+     * Instead of calling console.log, console.warn or console.error, DotVVM will call this function instead.
+     * Please keep in mind that the exact wording of log messages is not DotVVM public API and may change without notice.
+     * @example
+     * dotvvm.log.setLogger((next, level, area, ...args) => {
+     *     if (area == "validation" && /^This message should be an error$/.test(args[0])) {
+     *          level = "error"
+     *     }
+    *      previous(level, area, ...args) // call the default logger
+     * })
+     */
+    export function setLogger(newLogger: (next: typeof logger, level: ConsoleLogLevel, area: DotvvmLoggingArea, ...args: any) => void): void;
     export type DotvvmLoggingArea = ("debug" | "configuration" | "postback" | "spa" | "static-command" | "binding-handler" | "resource-loader" | "coercer" | "state-manager" | "validation" | "events" | "rest-api");
     export function logInfoVerbose(area: DotvvmLoggingArea, ...args: any[]): void;
     export function logInfo(area: DotvvmLoggingArea, ...args: any[]): void;
@@ -117,7 +130,7 @@ declare module "utils/isNumber" {
     export function isNumber(value: any): boolean;
 }
 declare module "metadata/enums" {
-    export function enumStringToInt(value: number | string, type: EnumTypeMetadata): number | null;
+    export function enumStringToInt(value: number | string | null | undefined, type: EnumTypeMetadata): number | null;
     export function enumIntToString(value: number, type: EnumTypeMetadata): string | null;
     export function tryCoerceEnum(value: any, type: EnumTypeMetadata): CoerceResult;
 }
@@ -313,6 +326,7 @@ declare module "viewModules/viewModuleManager" {
     export function initViewModule(name: string, viewIdOrElement: string | HTMLElement, rootElement: HTMLElement, properties?: object): ModuleContext;
     export function callViewModuleCommand(viewIdOrElement: string | HTMLElement, commandName: string, args: any[], allowAsync?: boolean): any;
     export function findComponent(viewIdOrElement: null | string | HTMLElement, name: string): [ModuleContext | null, DotvvmJsComponentFactory];
+    /** Registers a component to be used in any JsComponent, independent of view modules */
     export function registerGlobalComponent(name: string, c: DotvvmJsComponentFactory): void;
     export function registerNamedCommand(viewIdOrElement: string | HTMLElement, commandName: string, command: ModuleCommand, rootElement: HTMLElement): void;
     export function unregisterNamedCommand(viewIdOrElement: string | HTMLElement, commandName: string): void;
@@ -647,6 +661,7 @@ declare module "validation/validation" {
          *  `dotvvm.validation.removeErrors("/Detail")` removes all errors from the object in property root.Detail */
         removeErrors: typeof removeErrors;
     };
+    export const runClientSideValidation: (validationTarget: any, options: PostbackOptions) => void;
     export function init(): void;
     export type ValidationErrorDescriptor = {
         /** Error to be displayed to the user */
@@ -726,24 +741,22 @@ declare module "metadata/metadataHelper" {
 }
 declare module "translations/sortingHelper" {
     type ElementType = string | number | boolean;
-    export const orderBy: <T>(array: T[], selector: (item: T) => ElementType, typeId: string) => T[];
-    export const orderByDesc: <T>(array: T[], selector: (item: T) => ElementType, typeId: string) => T[];
+    export const orderBy: <T>(array: T[], selector: (item: T) => ElementType, typeId: string | null) => T[];
+    export const orderByDesc: <T>(array: T[], selector: (item: T) => ElementType, typeId: string | null) => T[];
 }
 declare module "translations/arrayHelper" {
     import { orderBy, orderByDesc } from "translations/sortingHelper";
-    export { add, addOrUpdate, addRange, clear, distinct, contains, firstOrDefault, insert, insertRange, lastOrDefault, max, min, orderBy, orderByDesc, removeAll, removeAt, removeFirst, removeLast, removeRange, reverse, setItem };
+    export { add, addOrUpdate, addRange, clear, distinct, contains, insert, insertRange, max, min, orderBy, orderByDesc, removeAll, removeAt, removeFirst, removeLast, removeRange, reverse, setItem };
     function add<T>(observable: any, element: T): void;
     function addOrUpdate<T>(observable: any, element: T, matcher: (e: T) => boolean, updater: (e: T) => T): void;
     function addRange<T>(observable: any, elements: T[]): void;
     function clear(observable: any): void;
     function distinct<T>(array: T[]): T[];
     function contains<T>(array: T[], value: T): boolean;
-    function firstOrDefault<T>(array: T[], predicate: (s: T) => boolean): T | null;
     function insert<T>(observable: any, index: number, element: T): void;
     function insertRange<T>(observable: any, index: number, elements: T[]): void;
-    function lastOrDefault<T>(array: T[], predicate: (s: T) => boolean): T | null;
-    function max<T>(array: T[], selector: (item: T) => number, throwIfEmpty: boolean): number | null;
-    function min<T>(array: T[], selector: (item: T) => number, throwIfEmpty: boolean): number | null;
+    function max<T>(array: T[], selector: (item: T) => number): number | null;
+    function min<T>(array: T[], selector: (item: T) => number): number | null;
     function removeAt<T>(observable: any, index: number): void;
     function removeAll<T>(observable: any, predicate: (s: T) => boolean): void;
     function removeRange<T>(observable: any, index: number, length: number): void;
@@ -759,7 +772,7 @@ declare module "translations/dictionaryHelper" {
     }[];
     export function clear(observable: any): void;
     export function containsKey<Key, Value>(dictionary: Dictionary<Key, Value>, identifier: Key): boolean;
-    export function getItem<Key, Value>(dictionary: Dictionary<Key, Value>, identifier: Key, defaultValue?: Value): Value;
+    export function getItem<Key, Value>(dictionary: Dictionary<Key, Value>, identifier: Key, defaultValue?: Value): Value | undefined;
     export function remove<Key, Value>(observable: any, identifier: Key): boolean;
     export function setItem<Key, Value>(observable: any, identifier: Key, value: Value): void;
 }
@@ -801,7 +814,7 @@ declare module "dotvvm-root" {
     import * as validation from "validation/validation";
     import { postBack } from "postback/postback";
     import { serialize } from "serialization/serialize";
-    import { serializeDate, parseDate } from "serialization/date";
+    import { serializeDate, parseDate, parseDateOnly, parseTimeOnly } from "serialization/date";
     import { deserialize } from "serialization/deserialize";
     import * as evaluator from "utils/evaluator";
     import * as globalize from "DotVVM.Globalize";
@@ -816,7 +829,7 @@ declare module "dotvvm-root" {
     import * as eventHub from "api/eventHub";
     import * as viewModuleManager from "viewModules/viewModuleManager";
     import { notifyModuleLoaded } from "postback/resourceLoader";
-    import { logError, logWarning, logInfo, logInfoVerbose, logPostBackScriptError } from "utils/logging";
+    import { logError, logWarning, logInfo, logInfoVerbose, logPostBackScriptError, setLogger } from "utils/logging";
     import * as metadataHelper from "metadata/metadataHelper";
     import { StateManager } from "state-manager";
     function init(culture: string): void;
@@ -880,6 +893,8 @@ declare module "dotvvm-root" {
             serialize: typeof serialize;
             serializeDate: typeof serializeDate;
             parseDate: typeof parseDate;
+            parseDateOnly: typeof parseDateOnly;
+            parseTimeOnly: typeof parseTimeOnly;
             deserialize: typeof deserialize;
         };
         metadata: {
@@ -903,6 +918,7 @@ declare module "dotvvm-root" {
             logInfoVerbose: typeof logInfoVerbose;
             logPostBackScriptError: typeof logPostBackScriptError;
             level: "normal" | "verbose";
+            setLogger: typeof setLogger;
         };
         options: {
             compressPOST: boolean;
@@ -1207,20 +1223,30 @@ type DotvvmFileSize = {
     FormattedText: KnockoutObservable<string>;
 };
 type DotvvmJsComponent = {
-    updateProps(p: {
+    /** Called after each update of dotvvm.state which changes any of the bound properties. Only the changed properties are listed in the `updatedProps` argument. */
+    updateProps(updatedProps: {
         [key: string]: any;
     }): void;
-    dispose(): void;
+    /** Called after the HTMLElement is removed from DOM.
+     * The component does not need to remove any child elements, but should clean any external data, such as subscription to dotvvm events */
+    dispose?(): void;
 };
 type DotvvmJsComponentFactory = {
+    /** Initializes the component on the specified HTMLElement.
+     * @param element The root HTMLElement of this component
+     * @param props An object listing all constants and `value` bindings from the `dot:JsComponent` instance
+     * @param commands An object listing all `command` and `staticCommand` bindings from the `dot:JsComponent` instance
+     * @param templates An object listing all content properties of the `dot:JsComponent`. The template is identified using its HTML id attribute, it can be rendered using ko.renderTemplate, KnockoutTemplateReactComponent or KnockoutTemplateSvelteComponent
+     * @param setProps A function which will attempt to write a value back into the bound property. Only certain `value` bindings can be updated, an exception is thown if it isn't possible
+     * @returns An object which will be notified about subsequent changes to the bound properties and when the component
+     */
     create(element: HTMLElement, props: {
         [key: string]: any;
     }, commands: {
         [key: string]: (args: any[]) => Promise<any>;
     }, templates: {
         [key: string]: string;
-    }, // TODO
-    setProps: (p: {
+    }, setProps: (p: {
         [key: string]: any;
     }) => void): DotvvmJsComponent;
 };