@conterra/ct-mapapps-typings 4.13.0 → 4.13.2-PRE-1

package/apprt-core/Locale.d.ts

@@ -2,8 +2,9 @@
  * Represents a locale.
  */
 export declare class Locale {
-    private lang;
-    private country;
+    #private;
+    private get lang();
+    private get country();
     /**
      * Creates a Locale
      *
@@ -33,5 +34,20 @@ export declare class Locale {
      * @returns The country code.
      */
     getCountry(): string;
+    /**
+     * Checks if country is present.
+     * @returns true if country has non empty value.
+     */
+    hasCountry(): boolean;
+    /**
+     * The locale string.
+     * @returns e.g. de-DE or de if no country is present.
+     */
+    getLocaleString(): string;
+    /**
+     * Creates a Intl.Locale instance.
+     * @returns Intl.Locale
+     */
+    getIntlLocale(): Intl.Locale;
 }
 export default Locale;

package/apprt-core/Logger.d.ts

@@ -112,6 +112,11 @@ export interface Logger {
      * @param args arguments filled into the placeholder or directly logged.
      */
     warn(msg: string, ...args: any[]): void;
+    /**
+     * Convenience method to log an error (without an additional message) as a warning.
+     * @param error the error to log
+     */
+    warn(error: Error): void;
     /**
      * Log a message at level ERROR.
      *
@@ -121,6 +126,11 @@ export interface Logger {
      * @param args arguments filled into the placeholder or directly logged.
      */
     error(msg: string, ...args: any[]): void;
+    /**
+     * Convenience method to log an error (without an additional message) as an error.
+     * @param error the error to log
+     */
+    error(error: Error): void;
     /**
      * Creates a new Logger, which will prefix each log message with the given prefix.
      *
@@ -185,9 +195,12 @@ export declare function getLogLevel(name: string): LogLevel;
 /**
  * Sets the logging configuration state.
  * Note that this function resets any existing configuration state.
+ *
  * @param config the new configuration. If empty or undefined, the configuration is cleared.
+ *               It can be string with the syntax `bundle:LEVEL,otherbundle:LEVEL`,
+ *               e.g. `apprt-core:DEBUG, map-init:WARN`
  */
-export declare function setLogConfig(config?: [string, LogLevel][]): void;
+export declare function setLogConfig(config?: [string, LogLevel][] | string): void;
 /**
  * Gets the current logging configuration state.
  * @returns Array like: [["", "DEBUG"] , ["apprt-core", "INFO"], ...];
@@ -226,3 +239,12 @@ export interface Writer {
  * @param newWriter the new Writer. If undefined, the console is used.
  */
 export declare function setWriter(newWriter?: Writer): void;
+/**
+ * Parses a configuration string into a logging configuration.
+ * @param loggingConfStr a string in the format `logger-name:LEVEL, other-logger-name: LEVEL`.
+ *                       e.g. `apprt-core:DEBUG, map-init:WARN`
+ *                       or   `DEBUG` for the root level.
+ *                       or   `apprt-core` to set it to DEBUG.
+ * @returns the parsed logging configuration.
+ */
+export declare function readConfigFromString(loggingConfStr?: string): [string, LogLevel][];

package/apprt-core/Mutable.d.ts

@@ -3,18 +3,17 @@ interface MembersTag<Members> {
     [_mutableMembers]: Members;
 }
 declare type PropertyKey = string | symbol;
-declare type Constructor<T> = new (...args: any[]) => T;
 declare type SimpleValueSpec = null | undefined | boolean | number | PropertyKey | bigint | any[];
 interface ComplexValueSpec<T> {
     value?: T;
-    type?: Constructor<T> | PropType<T>;
+    type?: PropType<T>;
     required?: boolean;
     writable?: boolean;
     depends?: PropertyKey[];
     init?(): T;
     get?(): T;
     set?(value: T): void;
-    cast?(value: T): T;
+    cast?(value: unknown): T;
     clone?(value: T): T;
 }
 declare type ValueSpec = SimpleValueSpec | ComplexValueSpec<any>;
@@ -34,7 +33,7 @@ export declare type MutableDefinition<T> = {
 };
 declare type IsEmptyObject<T> = T extends {} ? ({} extends T ? true : false) : false;
 declare type ResolveSpecType<Spec> = Spec extends {
-    type: PropType<infer T> | Constructor<infer T>;
+    type: PropType<infer T>;
 } ? T : Spec extends {
     value: infer V;
 } ? V : Spec extends ComplexValueSpec<infer V> ? V : never;
@@ -97,7 +96,7 @@ interface MutableBase<Members> extends MembersTag<Members> {
      * @param callback will be invoked when a property changes.
      * @returns a handle to stop watching
      */
-    watch(property: "*", callback: WatchCallback<PropertyName<this>, Properties<this>[PropertyName<this>]>): WatchHandle;
+    watch(property: "*", callback: WatchCallback<PublicPropertyName<this>, Properties<this>[PublicPropertyName<this>]>): WatchHandle;
 }
 /**
  * Represents the type of mutable instances built from some definition.
@@ -129,7 +128,7 @@ declare type RemoveFunctions<T> = {
 export declare type PropType<T> = {
     (): T;
 } | {
-    new (...args: never[]): T;
+    new (...args: never[]): T & object;
 } | {
     new (...args: string[]): Function;
 };
@@ -141,6 +140,8 @@ export declare type Properties<M extends Mutable<any>> = M extends MembersTag<in
  * This type is a union listing all valid property identifiers for the given mutable.
  */
 export declare type PropertyName<M extends Mutable<any>> = Extract<keyof Properties<M>, PropertyKey>;
+/** Excludes symbol properties from the list of property names (they are not watchable via '*') */
+declare type PublicPropertyName<M extends Mutable<any>> = Exclude<PropertyName<M>, symbol>;
 /**
  * Represents the type of a mutable class created from a definition.
  * Instances of this type are created by calling the `declare()` function.

package/apprt-core/TreeWalker.d.ts

@@ -68,14 +68,14 @@ export interface Visitor<NodeType extends Node> {
      * @param context The walker's context at current node.
      * @returns Indicates how the walker shall proceed, the default is VisitCodes.CONTINUE.
      */
-    getChildren(node: NodeType, context: Context<NodeType>): NodeType[] | void | undefined;
+    getChildren(node: NodeType, context: Context<NodeType>): NodeType[] | Iterable<NodeType> | void | undefined;
 }
 /** Base type of tree nodes. */
 export interface Node {
     /** Optional array of child nodes. */
     children?: Node[];
     /** Optional accessor function for child nodes. */
-    getChildren?(): Node[] | void | undefined;
+    getChildren?(): Node[] | Iterable<Node> | void | undefined;
 }
 /** Current visitor context. */
 export interface Context<NodeType extends Node> {

package/apprt-core/Types.d.ts

@@ -14,6 +14,10 @@ export declare type DeepWritable<T> = T extends Primitive ? T : T extends {} ? {
 export declare type DeepReadonly<T> = T extends Primitive ? T : T extends {} ? {
     readonly [P in keyof T]: DeepReadonly<T[P]>;
 } : T;
+/**
+ * Makes optional properties in the type `T` required.
+ */
+export declare type RequiredProps<T, K extends keyof T> = T & Required<Pick<T, K>>;
 interface IndexMap {
     "0": 0;
     "1": 1;

package/apprt-core/base64.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Base64 / binary data / UTF-8 strings utilities
+ *
+ * It ensures that UTF-8 characters are used when encoding to Base64.
+ *
+ * Based on code of: <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Base64_encoding_and_decoding>
+ *
+ * @module
+ *
+ * @example Encode string to Base64
+ * ```js
+ * import { encodeBase64 } from "apprt-core/base64";
+ *
+ * const base64str = encodeBase64("hello world");
+ * // base64str === "aGVsbG8gd29ybGQ="
+ * ```
+ *
+ * @example Decode Base64 string
+ * ```js
+ * import { decodeBase64 } from "apprt-core/base64";
+ *
+ * const str = decodeBase64("aGVsbG8gd29ybGQ=");
+ * // str === "hello world"
+ * ```
+ */
+/**
+ * Encodes a string into a Base64-encoded string.
+ * The string is first converted into a UTF-8 array and then encoded as Base64 string.
+ * @param input a string to encode.
+ * @returns Base64-encoded input
+ */
+export declare function encodeBase64(input: string): string;
+/**
+ * Decodes a Base64 string into the raw string.
+ * The Base64 string is first decoded into a UTF-8 array and then converted into a string.
+ * @param input Base64 string.
+ * @returns decoded input.
+ */
+export declare function decodeBase64(input: string): string;
+/**
+ * Converts a Base64 string into a UTF-8 array.
+ *
+ * If your aim is to build a buffer of 16-bit / 32-bit / 64-bit raw data,
+ * use the blocksSize argument, which is the number of bytes
+ * of which the uint8Array.buffer.bytesLength property must result a multiple.
+ * - 1 or omitted for ASCII, binary strings
+ *   (i.e., a string in which each character in the string is treated as a byte of binary data)
+ *   or UTF-8-encoded strings,
+ * - 2 for UTF-16 strings,
+ * - 4 for UTF-32 strings
+ * @param base64Input the base64 input
+ * @param blocksSize 1, 2 or 4 see above.
+ * @returns decoded bytes.
+ */
+export declare function base64DecodeToUtf8Arr(base64Input: string, blocksSize?: number): Uint8Array;
+/**
+ * Encodes a byte array into a Base64 string representation.
+ * @param utf8Array array of bytes.
+ * @returns Base64 string
+ */
+export declare function base64EncodeUtf8Arr(utf8Array: Uint8Array): string;
+/**
+ * Converts a UTF-8 byte array into a string.
+ * @param utf8Array byte array.
+ * @returns string.
+ */
+export declare function utf8ArrToStr(utf8Array: Uint8Array): string;
+/**
+ * Converts a string into a UTF-8 byte array.
+ * @param input string to encode as UTF-8 bytes.
+ * @returns UTF-8 byte array.
+ */
+export declare function strToUtf8Arr(input: string): Uint8Array;

package/apprt-core/comparators.d.ts

@@ -18,6 +18,14 @@ export declare type Comparator<T> = (a: T, b: T) => number;
  * @implements Comparator
  */
 export declare const DEFAULT_COMPARE: (a: any, b: any) => number;
+/**
+ * A comparison function suitable for sorting heterogenous primitive values to a predictable order.
+ * Values are ordered by type first and then compared by value.
+ * Note that `null` is treated as its own type for the purpose of this function, sorting directly after `undefined`.
+ *
+ * Symbols, objects and functions are grouped but have no useful ordering between them.
+ */
+export declare const TYPE_BASED_COMPARE: (a: any, b: any) => number;
 /**
  * Compares strings while treating uppercase and lowercase characters as equal.
  * This methods will throw an error if the objects are no strings.

package/apprt-core/config-dojo.d.ts

@@ -0,0 +1,8 @@
+import { RegisterOptions, SupportedValueTypes, ValueOrValueProvider } from "./config";
+import "dojo/_base/sniff";
+interface RegisterFunction<T> {
+    (key: keyof T, valueOrProvider: ValueOrValueProvider<keyof T, SupportedValueTypes>, options?: RegisterOptions): void;
+}
+export declare function registerDojoConfigKey<T>(registerFn: RegisterFunction<T>, name: keyof T, path: string, dconfig?: any): void;
+export declare function registerHasKey<T>(registerFn: RegisterFunction<T>, name: keyof T): void;
+export {};

package/apprt-core/config.d.ts

@@ -1,47 +1,363 @@
 import { DeepReadonly } from "./Types";
-import "dojo/_base/sniff";
 /**
  * Lists well known config property names and their types.
- *
- * TODO: will be split into config and environment detection!
  */
-export interface ConfigProperties {
-    /** True if deprecation messages shall be logged. */
-    "ct-log-deprecations": boolean;
-    /** TODO ?? */
-    "ct-fix-viewport": boolean;
-    "ct-fix-viewport-force": boolean;
-    "ct-dgrid-touchscroll": boolean;
-    /** True if content security policy settings prevent eval() etc. */
+export interface WellknownConfigKeys {
+    /**
+     * True if deprecation messages shall be logged.
+     */
+    "log-deprecations": boolean;
+    /**
+     * Is the debug mode enabled
+     */
+    "debug": boolean;
+    /**
+     *  The configured locale.
+     *  Use `apprt-core/Locale.getCurrent()` to access the value.
+     */
+    "locale": string;
+    /**
+     * The globally supported locales.
+     */
+    "supported-locales": string[];
+    /**
+     *  URL pointing to the current app directory.
+     */
+    "app-base-url": string;
+    /**
+     * The global logging configuration.
+     * A string of the format `logger:LEVEL,other:LEVEL`.
+     * Level = DEBUG, INFO, WARN, ERROR, OFF
+     * Is interpreted by apprt-core/Logger
+     */
+    "logging": string;
+    /**
+     * URL to the js-registry providing the test bundles.
+     * Only available during test execution.
+     */
+    "testing-jsregistry-url": string;
+    /**
+     * Registry URL used to fetch the apprt system.
+     */
+    "apprt-jsregistry-url": string;
+    /**
+     * The name of the default application.
+     */
+    "app-launch-default-app": string;
+    /**
+     * Defines that pre-fetching of module.js files via registry/layer.js is enabled.
+     */
+    "app-launch-prefetch-enabled": boolean;
+    /**
+     * Defines that during the pre-fetching main.js files should be included.
+     * @deprecated the settings is obsolete.
+     */
+    "app-launch-prefetch-main": boolean;
+    /**
+     * Defines that switching to HTTP POST is allowed during layer.js pre-fetching.
+     */
+    "app-launch-prefetch-with-post-enabled": boolean;
+    /**
+     * Defines that the layer.js request is using gzip encoded parameters to keep the parameter size short.
+     */
+    "app-launch-prefetch-params-compressed": boolean;
+    /**
+     * Defines that the app.json and bundles.json requests should use jsonp.
+     * @deprecated this support will be dropped for security reasons.
+     */
+    "app-launch-jsonp-enabled": boolean;
+    /**
+     * Enables statistics calculation during app start.
+     */
+    "app-launch-statistics-enabled": boolean;
+    /**
+     * Information of apprt-boot for the Launcher.
+     */
+    "apprt-boot-loader-info": any;
+    /**
+     * A global configured Enterprise-Portal URL.
+     */
+    "arcgis-portal-url": string;
+    /**
+     * URL to the /agol/token endpoint of map.apps.
+     * Which provides an technical user token to e.g. consume a geolocation service as anonymous app user.
+     */
+    "esri-identity-app-token-url": string;
+    /**
+     * Enables the use of the /agol/token endpoint.
+     */
+    "esri-identity-app-token-enabled": boolean;
+    /**
+     * Enables the persistence of the esri/identity/IdentityManager state in the local storage.
+     */
+    "esri-identity-state-persist": boolean;
+    /**
+     * The name of the state in the local storage.
+     */
+    "esri-identity-state-name": string;
+    /**
+     * The prefix of the state in the local storage.
+     * If this is not configured then the default prefix is the app location.
+     * This should prevent interferences between apps.
+     */
+    "esri-identity-state-name-prefix": string;
+    /**
+     * Allows the esri/IdentityManager to send credentials via http.
+     * Note this is only intended for development purpose
+     * and should never be enabled during production.
+     */
+    "esri-identity-allow-credentials-over-http": boolean;
+    /**
+     * Enables client side oauth for the application.
+     */
+    "oauth-enabled": boolean;
+    /**
+     * Which expiration should the requested oauth token have.
+     */
+    "oauth-access-token-expiration": number;
+    /**
+     * The client-id or app-id to authenticated with.
+     */
+    "oauth-app-id": string;
+    /**
+     * A special namespace value.
+     * Experimental, ignore that.
+     */
+    "oauth-namespace": string;
+    /**
+     * Should the login dialog be shown inside a popup.
+     */
+    "oauth-use-popup": boolean;
+    /**
+     * URL to a callback page which consumes the access token.
+     * Only of interest if oauth-use-popup is true.
+     */
+    "oauth-popup-callback-page": string;
+    /**
+     * Flag to enforce a login,
+     * Experimental, ignore that.
+     */
+    "oauth-force-login": string;
+    /**
+     * Refresh interval for geo-location updates.
+     */
+    "geolocation-update-interval": number;
+    /**
+     * Maximal allowed URL length before automatically switching to POST.
+     */
+    "request-max-url-length": number;
+    /**
+     * Default request timeout.
+     */
+    "request-timeout": number;
+    /**
+     * Disables automatic CORS proxy fallback.
+     */
+    "request-proxy-disabled": boolean;
+    /**
+     * The default proxy URL.
+     */
+    "request-proxy-url": string;
+    /**
+     * Proxy use rules.
+     */
+    "request-proxy-rules": {
+        origin: string;
+        proxyUrl?: string;
+    }[];
+    /**
+     * The trusted servers.
+     * Required for secure CORS communication.
+     */
+    "request-trusted-servers": string[];
+    /**
+     * Flag for apprt-request to return dojo/Deferred instead of Promises.
+     */
+    "request-return-dojo-deferred": boolean;
+    /**
+     * Plain esri key, provides a way to configure the properties in esri/config.
+     * Used by apprt-esri-init.
+     */
+    "esri-conf": {
+        [prop: string]: SupportedValueTypes;
+    };
+    /**
+     * Is an algorithm to re-calcuate the viewport size for mobile enabled.
+     */
+    "mobile-fix-viewport": boolean;
+    /**
+     * Should the use of the fix algorithm be enforced.
+     */
+    "mobile-fix-viewport-force": boolean;
+    /**
+     * Is touch scroll enabled for dgrid.
+     */
+    "dgrid-touchscroll": boolean;
+}
+/** Valid configuration property names. */
+export declare type ConfigKey = keyof WellknownConfigKeys;
+/**
+ * Lists well known environment property names and their types.
+ */
+export interface WellknownEnvKeys {
+    /**
+     * True if content security policy settings prevent eval() etc.
+     */
     "csp-restrictions": boolean;
+    /**
+     * True if WebAssembly is enabled.
+     */
+    "webassembly": boolean;
+    /**
+     * Detection if the client device is touch enabled.
+     */
     "touch": boolean;
+    /**
+     * Detection if the client is a mobile device.
+     */
     "mobile": boolean;
+    /**
+     * Detection if the client is the Internet Explorer.
+     */
     "ie": number;
+    /**
+     * Detection if the client is FireFox.
+     */
     "ff": number;
+    /**
+     * Detection if the client is Safari.
+     */
     "safari": number;
+    /**
+     * Detection if the client is an Android device.
+     */
     "android": number;
-    "native-xhr2": boolean;
 }
-/** Valid configuration property names. */
-export declare type ConfigPropertyKey = keyof ConfigProperties;
+/** Valid environment property names. */
+export declare type EnvKey = keyof WellknownEnvKeys;
 /** Supported value types. */
-export declare type ConfigValue = undefined | null | boolean | number | string | ConfigValue[] | {
-    [prop: string]: ConfigValue;
+export declare type SupportedValueTypes = undefined | null | boolean | number | string | SupportedValueTypes[] | {
+    [prop: string]: SupportedValueTypes;
 };
-declare type ValueProvider<T> = T | (() => T);
+/**
+ * A function producing a result for a given key.
+ */
+export declare type ValueProvider<KeyType, ResultType> = (key: KeyType) => ResultType | undefined;
+/**
+ * Type used by the register functions to
+ * distinguish a plain value or a function providing the value.
+ */
+export declare type ValueOrValueProvider<KeyType, ResultType> = ResultType | ValueProvider<KeyType, ResultType>;
+/**
+ * Options accepted by the register* functions.
+ */
+export interface RegisterOptions {
+    /**
+     * If `true` and the value is a provider function, it is only invoked once.
+     * Otherwise the function is invoked for every call for key.
+     * Default is `true`.
+     */
+    cacheProvidedValue?: boolean;
+    /**
+     * If `true` and there is a provider already, the existing provider is replaced.
+     * Otherwise an error is thrown.
+     */
+    overwrite?: boolean;
+}
+/**
+ * A value interceptor.
+ */
+export interface Interceptor {
+    /**
+     * An interceptor is informed about any config key access.
+     * The lookupValue function can be used to fetch the original configuration value.
+     * An interceptor may return custom values.
+     *
+     * @param key config key
+     * @param lookupValue a function providing the original config value
+     * @returns the intercepted config value or undefined
+     */
+    (key: string, lookupValue: () => SupportedValueTypes): SupportedValueTypes | undefined;
+}
+/**
+ * This class implements the internal lazy configuration state.
+ * It is exported for test purpose only.
+ *
+ * @internal
+ */
+export declare class LazyValues<SupportedKeys, Key extends keyof SupportedKeys = keyof SupportedKeys> {
+    #private;
+    interceptor: Interceptor | undefined;
+    get<K extends Key>(key: K): DeepReadonly<SupportedKeys[K]> | undefined;
+    registeredKeys(): Set<Key>;
+    register(key: Key, valueProvider: ValueOrValueProvider<Key, SupportedValueTypes>, { cacheProvidedValue, overwrite }?: RegisterOptions): void;
+    isRegistered(key: Key): boolean;
+    unregister(key: Key): boolean;
+}
 /**
  * Returns the configuration value associated with the given key.
- * Throws an exception if the key is not known.
+ * Returns `undefined` if the key is unknown.
+ *
+ * @param key one of the WellknownConfigKeys
+ * @returns the config value matching the key.
  */
-export declare function config<K extends ConfigPropertyKey>(key: K): DeepReadonly<ConfigProperties[K]> | undefined;
-export default config;
+export declare function configValue<Key extends ConfigKey>(key: Key): DeepReadonly<WellknownConfigKeys[Key]> | undefined;
 /**
  * Registers a new key with the configuration.
- * Keys and values must also be declared at the type level by extending the `ConfigProperties` interface.
+ * Keys and values must also be declared at the type-level by extending the `WellknownConfigKeys` interface.
  *
  * Throws an exception if the key was already registered.
  *
  * @param key the configuration key
- * @param value the value or a function returning the value (for lazy evaluation).
+ * @param valueOrProvider the value or a function returning the value (for lazy evaluation).
+ * @param options registration flags
+ */
+export declare function registerConfigValue(key: ConfigKey, valueOrProvider: ValueOrValueProvider<ConfigKey, SupportedValueTypes>, options?: RegisterOptions): void;
+/**
+ * The intention of this function is to make testing simpler.
+ * A test can register a config value and unregister it afterwards.
+ *
+ * @param key a config key
+ * @returns true if conf value was un-registered(previously registered)
+ */
+export declare function unregisterConfigValue(key: ConfigKey): boolean;
+/**
+ * The intention of this function is to make testing simpler.
+ *
+ * Do not forget to unset your interceptor after the tests by invoking this function with no arguments.
+ * @param interceptor a callback informed about any config value access.
+ */
+export declare function setConfigValueInterceptor(interceptor?: Interceptor): void;
+/**
+ * Returns the environment value associated with the given key.
+ * Returns `undefined` if the key is not known.
+ *
+ * @param key one of the WellknownEnvKeys
+ * @returns the environment value matching the key.
+ */
+export declare function envValue<Key extends EnvKey>(key: Key): DeepReadonly<WellknownEnvKeys[Key]> | undefined;
+/**
+ * Registers a new environment key with the configuration.
+ * Keys and values must also be declared at the type-level by extending the `WellknownEnvKeys` interface.
+ *
+ * Throws an exception if the key was already registered.
+ *
+ * @param key the env key
+ * @param valueOrProvider the value or a function returning the value (for lazy evaluation).
+ * @param options registration flags
+ */
+export declare function registerEnvValue(key: EnvKey, valueOrProvider: ValueOrValueProvider<EnvKey, SupportedValueTypes>, options?: RegisterOptions): void;
+/**
+ * The intention of this function is to make testing simpler.
+ * A test can register a env value and unregister it afterwards.
+ * @param key a env key
+ * @returns true if env value was un-registered(previously registered)
+ */
+export declare function unregisterEnvValue(key: EnvKey): boolean;
+/**
+ * The intention of this function is to make testing simpler.
+ *
+ * Do not forget to unset the interceptor after the tests.
+ * @param interceptor a callback informed about any env value access.
  */
-export declare function register<K extends ConfigPropertyKey>(key: K, value: ValueProvider<Extract<ConfigProperties[K], ConfigValue>>): void;
+export declare function setEnvValueInterceptor(interceptor?: Interceptor): void;

package/apprt-core/deprecate.d.ts

@@ -1,6 +1,6 @@
 /**
  * Logs a deprecation warning.
- * Deprecation logs can be configured via `ct-log-deprecations` flag.
+ * Deprecation logs can be configured via `log-deprecations` flag.
  * @example
  * ```js
  * import deprecate from "apprt-core/deprecate";

package/apprt-core/string-escape.d.ts

@@ -14,4 +14,5 @@
  * ```
  */
 export declare function stringEscape(str: string | number): string;
+export { stringEscape as escapeHtml };
 export default stringEscape;