@widget-js/core 0.0.7 → 0.0.9

package/dist/esm/model/WidgetParams.js

@@ -0,0 +1,139 @@
+/**
+ * 组件参数，如宽，高，id，语言等环境参数
+ */
+import { parseQuery } from "../router/query";
+export class WidgetParams {
+    /**
+     * 将组件参数转为url参数
+     * @param object
+     * @return URLSearchParams  w_w=2&w_h=2&w_id=21&w_width=156&w_height=156
+     */
+    toUrlParams() {
+        const urlParams = new URLSearchParams();
+        const ownPropertyNames = Object.getOwnPropertyNames(this);
+        for (let ownPropertyName of ownPropertyNames) {
+            const key = ownPropertyName;
+            const value = this[key];
+            if (value) {
+                urlParams.append(WidgetParams.PARAM_PREFIX + ownPropertyName, value.toString());
+            }
+        }
+        return urlParams;
+    }
+    getPersistKey() {
+        return `${this.name}-${this.id}`;
+    }
+    /**
+     * 从当前地址解析组件参数：
+     * http://localhost:8080/#/widget/config/labor_progress?w_w=2&w_h=2&w_width=156&w_height=156
+     * =>
+     *  {w:2,h:2,id:21,width:156,height:156}
+     */
+    static fromCurrentLocation() {
+        const href = window.location.href;
+        let queryString = href.split("?")[1];
+        return this.fromObject(parseQuery(queryString));
+    }
+    static setValue(widgetEnv, key, value) {
+        const keyWithoutPrefix = key.replace(this.PARAM_PREFIX, "");
+        if (keyWithoutPrefix == WidgetParams.PARAM_ID) {
+            widgetEnv.id = value;
+        }
+        else if (keyWithoutPrefix == WidgetParams.PARAM_X) {
+            widgetEnv.x = parseInt(value);
+        }
+        else if (keyWithoutPrefix == WidgetParams.PARAM_Y) {
+            widgetEnv.y = parseInt(value);
+        }
+        else if (keyWithoutPrefix == WidgetParams.PARAM_H) {
+            widgetEnv.h = parseInt(value);
+        }
+        else if (keyWithoutPrefix == WidgetParams.PARAM_W) {
+            widgetEnv.w = parseInt(value);
+        }
+        else if (keyWithoutPrefix == WidgetParams.PARAM_LANG) {
+            widgetEnv.lang = value;
+        }
+        else if (keyWithoutPrefix == WidgetParams.PARAM_THEME) {
+            widgetEnv.theme = value;
+        }
+        else if (keyWithoutPrefix == WidgetParams.PARAM_MODE) {
+            widgetEnv.mode = parseInt(value);
+        }
+        else if (keyWithoutPrefix == WidgetParams.PARAM_RADIUS) {
+            widgetEnv.radius = parseInt(value);
+        }
+        else if (keyWithoutPrefix == WidgetParams.PARAM_WIDTH) {
+            widgetEnv.width = parseInt(value);
+        }
+        else if (keyWithoutPrefix == WidgetParams.PARAM_HEIGHT) {
+            widgetEnv.height = parseInt(value);
+        }
+        else if (keyWithoutPrefix == WidgetParams.PARAM_NAME) {
+            widgetEnv.name = value;
+        }
+        else if (keyWithoutPrefix == WidgetParams.PARAM_TITLE) {
+            widgetEnv.title = value;
+        }
+        else if (keyWithoutPrefix == WidgetParams.PARAM_PREVIEW) {
+            widgetEnv.preview = (value === 'true');
+        }
+    }
+    /**
+     * 从对象键值对中初始化组件参数
+     * {w_w:2,w_h:2,w_id:21,w_width:156,w_height:156}=>
+     *  {w:2,h:2,id:21,width:156,height:156}
+     * @param object
+     */
+    static fromObject(object) {
+        const widgetEnv = new WidgetParams();
+        const ownPropertyNames = Object.getOwnPropertyNames(object);
+        for (let ownPropertyName of ownPropertyNames) {
+            const key = ownPropertyName;
+            const value = object[key];
+            this.setValue(widgetEnv, key, value);
+        }
+        return widgetEnv;
+    }
+}
+WidgetParams.PARAM_PREFIX = "w_";
+WidgetParams.PARAM_ID = "id";
+WidgetParams.PARAM_W = "w";
+WidgetParams.PARAM_H = "h";
+WidgetParams.PARAM_WIDTH = "width";
+WidgetParams.PARAM_HEIGHT = "height";
+WidgetParams.PARAM_X = "x";
+WidgetParams.PARAM_Y = "y";
+WidgetParams.PARAM_LANG = "lang";
+WidgetParams.PARAM_THEME = "theme";
+WidgetParams.PARAM_MODE = "mode";
+WidgetParams.PARAM_RADIUS = "radius";
+WidgetParams.PARAM_NAME = "name";
+WidgetParams.PARAM_TITLE = "title";
+WidgetParams.PARAM_PREVIEW = "preview";
+WidgetParams.PARAMS = [
+    WidgetParams.PARAM_ID,
+    WidgetParams.PARAM_W,
+    WidgetParams.PARAM_H,
+    WidgetParams.PARAM_X,
+    WidgetParams.PARAM_Y,
+    WidgetParams.PARAM_LANG,
+    WidgetParams.PARAM_THEME,
+    WidgetParams.PARAM_MODE,
+    WidgetParams.PARAM_WIDTH,
+    WidgetParams.PARAM_HEIGHT,
+    WidgetParams.PARAM_NAME,
+    WidgetParams.PARAM_TITLE,
+    WidgetParams.PARAM_PREVIEW,
+];
+export var ThemeMode;
+(function (ThemeMode) {
+    ThemeMode["AUTO"] = "auto";
+    ThemeMode["LIGHT"] = "LIGHT";
+    ThemeMode["DARK"] = "DARK";
+})(ThemeMode || (ThemeMode = {}));
+export var WidgetHostMode;
+(function (WidgetHostMode) {
+    WidgetHostMode[WidgetHostMode["DEFAULT"] = 0] = "DEFAULT";
+    WidgetHostMode[WidgetHostMode["OVERLAP"] = 1] = "OVERLAP";
+})(WidgetHostMode || (WidgetHostMode = {}));

package/dist/esm/repository/WidgetDataRepository.js

@@ -0,0 +1,81 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import localforage from "localforage";
+import { BroadcastEvent } from "../model/BroadcastEvent";
+import { ElectronApi } from "../api/ElectronApi";
+export class WidgetDataRepository {
+    /**
+     * 保存组件数据
+     * @param data
+     */
+    static save(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let store = this.getStore(data.name);
+            const result = yield store.setItem(this.getKey(data.name, data.id), JSON.stringify(data));
+            const broadcastEvent = new BroadcastEvent(BroadcastEvent.TYPE_WIDGET_UPDATED, "", data);
+            yield ElectronApi.sendBroadcastEvent(broadcastEvent);
+            return result;
+        });
+    }
+    /**
+     * 获取组件 LocalForage 存储实例
+     * @param name
+     */
+    static getStore(name) {
+        if (this.stores.has(name)) {
+            return this.stores.get(name);
+        }
+        const store = localforage.createInstance({ name: name });
+        this.stores.set(name, store);
+        return store;
+    }
+    /**
+     * 通过组件名保存组件信息，通常用于存储可以在同类组件中共用的数据
+     * @param name
+     * @param json
+     */
+    static saveByName(name, json) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let store = this.getStore(name);
+            const result = yield store.setItem(name, json);
+            const broadcastEvent = new BroadcastEvent(BroadcastEvent.TYPE_WIDGET_UPDATED, "", { name, json });
+            yield ElectronApi.sendBroadcastEvent(broadcastEvent);
+            return result;
+        });
+    }
+    static findByName(name, type) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let store = this.getStore(name);
+            let result = yield store.getItem(name);
+            if (result) {
+                const widgetData = new type(name);
+                widgetData.parseJSON(JSON.parse(result));
+                return widgetData;
+            }
+            return undefined;
+        });
+    }
+    static find(name, id, type) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let store = this.getStore(name);
+            let result = yield store.getItem(this.getKey(name, id));
+            if (result) {
+                const widgetData = new type(name, id);
+                widgetData.parseJSON(JSON.parse(result));
+                return widgetData;
+            }
+            return undefined;
+        });
+    }
+    static getKey(name, id) {
+        return `${name}@${id}`;
+    }
+}
+WidgetDataRepository.stores = new Map();

package/dist/esm/router/encoding.js

@@ -0,0 +1,135 @@
+/**
+ * Encoding Rules ␣ = Space Path: ␣ " < > # ? { } Query: ␣ " < > # & = Hash: ␣ "
+ * < > `
+ *
+ * On top of that, the RFC3986 (https://tools.ietf.org/html/rfc3986#section-2.2)
+ * defines some extra characters to be encoded. Most browsers do not encode them
+ * in encodeURI https://github.com/whatwg/url/issues/369, so it may be safer to
+ * also encode `!'()*`. Leaving un-encoded only ASCII alphanumeric(`a-zA-Z0-9`)
+ * plus `-._~`. This extra safety should be applied to query by patching the
+ * string returned by encodeURIComponent encodeURI also encodes `[\]^`. `\`
+ * should be encoded to avoid ambiguity. Browsers (IE, FF, C) transform a `\`
+ * into a `/` if directly typed in. The _backtick_ (`````) should also be
+ * encoded everywhere because some browsers like FF encode it when directly
+ * written while others don't. Safari and IE don't encode ``"<>{}``` in hash.
+ */
+// const EXTRA_RESERVED_RE = /[!'()*]/g
+// const encodeReservedReplacer = (c: string) => '%' + c.charCodeAt(0).toString(16)
+const HASH_RE = /#/g; // %23
+const AMPERSAND_RE = /&/g; // %26
+const SLASH_RE = /\//g; // %2F
+const EQUAL_RE = /=/g; // %3D
+const IM_RE = /\?/g; // %3F
+export const PLUS_RE = /\+/g; // %2B
+/**
+ * NOTE: It's not clear to me if we should encode the + symbol in queries, it
+ * seems to be less flexible than not doing so and I can't find out the legacy
+ * systems requiring this for regular requests like text/html. In the standard,
+ * the encoding of the plus character is only mentioned for
+ * application/x-www-form-urlencoded
+ * (https://url.spec.whatwg.org/#urlencoded-parsing) and most browsers seems lo
+ * leave the plus character as is in queries. To be more flexible, we allow the
+ * plus character on the query, but it can also be manually encoded by the user.
+ *
+ * Resources:
+ * - https://url.spec.whatwg.org/#urlencoded-parsing
+ * - https://stackoverflow.com/questions/1634271/url-encoding-the-space-character-or-20
+ */
+const ENC_BRACKET_OPEN_RE = /%5B/g; // [
+const ENC_BRACKET_CLOSE_RE = /%5D/g; // ]
+const ENC_CARET_RE = /%5E/g; // ^
+const ENC_BACKTICK_RE = /%60/g; // `
+const ENC_CURLY_OPEN_RE = /%7B/g; // {
+const ENC_PIPE_RE = /%7C/g; // |
+const ENC_CURLY_CLOSE_RE = /%7D/g; // }
+const ENC_SPACE_RE = /%20/g; // }
+/**
+ * Encode characters that need to be encoded on the path, search and hash
+ * sections of the URL.
+ *
+ * @internal
+ * @param text - string to encode
+ * @returns encoded string
+ */
+function commonEncode(text) {
+    return encodeURI('' + text)
+        .replace(ENC_PIPE_RE, '|')
+        .replace(ENC_BRACKET_OPEN_RE, '[')
+        .replace(ENC_BRACKET_CLOSE_RE, ']');
+}
+/**
+ * Encode characters that need to be encoded on the hash section of the URL.
+ *
+ * @param text - string to encode
+ * @returns encoded string
+ */
+export function encodeHash(text) {
+    return commonEncode(text)
+        .replace(ENC_CURLY_OPEN_RE, '{')
+        .replace(ENC_CURLY_CLOSE_RE, '}')
+        .replace(ENC_CARET_RE, '^');
+}
+/**
+ * Encode characters that need to be encoded query values on the query
+ * section of the URL.
+ *
+ * @param text - string to encode
+ * @returns encoded string
+ */
+export function encodeQueryValue(text) {
+    return (commonEncode(text)
+        // Encode the space as +, encode the + to differentiate it from the space
+        .replace(PLUS_RE, '%2B')
+        .replace(ENC_SPACE_RE, '+')
+        .replace(HASH_RE, '%23')
+        .replace(AMPERSAND_RE, '%26')
+        .replace(ENC_BACKTICK_RE, '`')
+        .replace(ENC_CURLY_OPEN_RE, '{')
+        .replace(ENC_CURLY_CLOSE_RE, '}')
+        .replace(ENC_CARET_RE, '^'));
+}
+/**
+ * Like `encodeQueryValue` but also encodes the `=` character.
+ *
+ * @param text - string to encode
+ */
+export function encodeQueryKey(text) {
+    return encodeQueryValue(text).replace(EQUAL_RE, '%3D');
+}
+/**
+ * Encode characters that need to be encoded on the path section of the URL.
+ *
+ * @param text - string to encode
+ * @returns encoded string
+ */
+export function encodePath(text) {
+    return commonEncode(text).replace(HASH_RE, '%23').replace(IM_RE, '%3F');
+}
+/**
+ * Encode characters that need to be encoded on the path section of the URL as a
+ * param. This function encodes everything {@link encodePath} does plus the
+ * slash (`/`) character. If `text` is `null` or `undefined`, returns an empty
+ * string instead.
+ *
+ * @param text - string to encode
+ * @returns encoded string
+ */
+export function encodeParam(text) {
+    return text == null ? '' : encodePath(text).replace(SLASH_RE, '%2F');
+}
+/**
+ * Decode text using `decodeURIComponent`. Returns the original text if it
+ * fails.
+ *
+ * @param text - string to decode
+ * @returns decoded string
+ */
+export function decode(text) {
+    try {
+        return decodeURIComponent('' + text);
+    }
+    catch (err) {
+        // __DEV__ && warn(`Error decoding "${text}". Using original value`)
+    }
+    return '' + text;
+}

package/dist/esm/router/query.js

@@ -0,0 +1,101 @@
+import { decode, encodeQueryKey, encodeQueryValue, PLUS_RE } from './encoding';
+const isArray = Array.isArray;
+/**
+ * Transforms a queryString into a {@link LocationQuery} object. Accept both, a
+ * version with the leading `?` and without Should work as URLSearchParams
+ * @internal
+ *
+ * @param search - search string to parse
+ * @returns a query object
+ */
+export function parseQuery(search) {
+    const query = {};
+    // avoid creating an object with an empty key and empty value
+    // because of split('&')
+    if (search === '' || search === '?')
+        return query;
+    const hasLeadingIM = search[0] === '?';
+    const searchParams = (hasLeadingIM ? search.slice(1) : search).split('&');
+    for (let i = 0; i < searchParams.length; ++i) {
+        // pre decode the + into space
+        const searchParam = searchParams[i].replace(PLUS_RE, ' ');
+        // allow the = character
+        const eqPos = searchParam.indexOf('=');
+        const key = decode(eqPos < 0 ? searchParam : searchParam.slice(0, eqPos));
+        const value = eqPos < 0 ? null : decode(searchParam.slice(eqPos + 1));
+        if (key in query) {
+            // an extra variable for ts types
+            let currentValue = query[key];
+            if (!isArray(currentValue)) {
+                currentValue = query[key] = [currentValue];
+            }
+            // we force the modification
+            ;
+            currentValue.push(value);
+        }
+        else {
+            query[key] = value;
+        }
+    }
+    return query;
+}
+/**
+ * Stringifies a {@link LocationQueryRaw} object. Like `URLSearchParams`, it
+ * doesn't prepend a `?`
+ *
+ * @internal
+ *
+ * @param query - query object to stringify
+ * @returns string version of the query without the leading `?`
+ */
+export function stringifyQuery(query) {
+    let search = '';
+    for (let key in query) {
+        const value = query[key];
+        key = encodeQueryKey(key);
+        if (value == null) {
+            // only null adds the value
+            if (value !== undefined) {
+                search += (search.length ? '&' : '') + key;
+            }
+            continue;
+        }
+        // keep null values
+        const values = isArray(value)
+            ? value.map(v => v && encodeQueryValue(v))
+            : [value && encodeQueryValue(value)];
+        values.forEach(value => {
+            // skip undefined values in arrays as if they were not present
+            // smaller code than using filter
+            if (value !== undefined) {
+                // only append & with non-empty search
+                search += (search.length ? '&' : '') + key;
+                if (value != null)
+                    search += '=' + value;
+            }
+        });
+    }
+    return search;
+}
+/**
+ * Transforms a {@link LocationQueryRaw} into a {@link LocationQuery} by casting
+ * numbers into strings, removing keys with an undefined value and replacing
+ * undefined with null in arrays
+ *
+ * @param query - query object to normalize
+ * @returns a normalized query object
+ */
+export function normalizeQuery(query) {
+    const normalizedQuery = {};
+    for (const key in query) {
+        const value = query[key];
+        if (value !== undefined) {
+            normalizedQuery[key] = isArray(value)
+                ? value.map(v => (v == null ? null : '' + v))
+                : value == null
+                    ? value
+                    : '' + value;
+        }
+    }
+    return normalizedQuery;
+}

package/dist/types/index.d.ts

@@ -1,5 +1,7 @@
 export * from "./model/Widget";
 export * from "./model/BroadcastEvent";
 export * from "./model/WidgetData";
+export * from "./model/WidgetParams";
 export * from "./api/ElectronApi";
 export * from "./api/Keys";
+export * from "./repository/WidgetDataRepository";

package/dist/types/model/BroadcastEvent.d.ts

@@ -1,4 +1,5 @@
 export declare class BroadcastEvent {
+    static TYPE_WIDGET_UPDATED: string;
     type: string;
     from: string;
     payload: any;

package/dist/types/model/WidgetData.d.ts

@@ -1,18 +1,35 @@
 /**
  * 组件配置数据，用于存储组件自定义页面所设置的数据
  */
-export default class WidgetData {
-    id: string;
+export declare class WidgetData {
+    /**
+     * 组件id
+     */
+    id?: string;
+    /**
+     * 组件名
+     */
     name: string;
-    title?: string;
+    /**
+     * 背景颜色
+     */
     backgroundColor?: string;
+    /**
+     * 文字颜色
+     */
     color?: string;
+    /**
+     * 字体大小
+     */
     fontSize?: number;
-    borderRadius?: number;
-    date?: string;
     /**
-     * 其他数据，以JSON格式放在这里
+     * 字体
      */
-    extraJSON?: any;
-    constructor(name: string, id: string);
+    fontFamily?: string;
+    /**
+     * 圆角半径
+     */
+    borderRadius?: number;
+    constructor(name: string, id?: string);
+    parseJSON(json: {}): void;
 }

package/dist/types/model/WidgetParams.d.ts

@@ -0,0 +1,63 @@
+export declare class WidgetParams {
+    static readonly PARAM_PREFIX = "w_";
+    static readonly PARAM_ID = "id";
+    static readonly PARAM_W = "w";
+    static readonly PARAM_H = "h";
+    static readonly PARAM_WIDTH = "width";
+    static readonly PARAM_HEIGHT = "height";
+    static readonly PARAM_X = "x";
+    static readonly PARAM_Y = "y";
+    static readonly PARAM_LANG = "lang";
+    static readonly PARAM_THEME = "theme";
+    static readonly PARAM_MODE = "mode";
+    static readonly PARAM_RADIUS = "radius";
+    static readonly PARAM_NAME = "name";
+    static readonly PARAM_TITLE = "title";
+    static readonly PARAM_PREVIEW = "preview";
+    static readonly PARAMS: string[];
+    id?: string;
+    w?: number;
+    width?: number;
+    height?: number;
+    h?: number;
+    x?: number;
+    y?: number;
+    preview?: boolean;
+    lang?: string;
+    theme?: ThemeMode;
+    mode?: WidgetHostMode;
+    radius?: number;
+    name?: string;
+    title?: string;
+    /**
+     * 将组件参数转为url参数
+     * @param object
+     * @return URLSearchParams  w_w=2&w_h=2&w_id=21&w_width=156&w_height=156
+     */
+    toUrlParams(): URLSearchParams;
+    getPersistKey(): string;
+    /**
+     * 从当前地址解析组件参数：
+     * http://localhost:8080/#/widget/config/labor_progress?w_w=2&w_h=2&w_width=156&w_height=156
+     * =>
+     *  {w:2,h:2,id:21,width:156,height:156}
+     */
+    static fromCurrentLocation(): WidgetParams;
+    private static setValue;
+    /**
+     * 从对象键值对中初始化组件参数
+     * {w_w:2,w_h:2,w_id:21,w_width:156,w_height:156}=>
+     *  {w:2,h:2,id:21,width:156,height:156}
+     * @param object
+     */
+    static fromObject(object: any): WidgetParams;
+}
+export declare enum ThemeMode {
+    AUTO = "auto",
+    LIGHT = "LIGHT",
+    DARK = "DARK"
+}
+export declare enum WidgetHostMode {
+    DEFAULT = 0,
+    OVERLAP = 1
+}

package/dist/types/repository/WidgetDataRepository.d.ts

@@ -0,0 +1,27 @@
+import { WidgetData } from "../model/WidgetData";
+export declare class WidgetDataRepository {
+    private static stores;
+    /**
+     * 保存组件数据
+     * @param data
+     */
+    static save(data: WidgetData): Promise<string>;
+    /**
+     * 获取组件 LocalForage 存储实例
+     * @param name
+     */
+    static getStore(name: string): LocalForage;
+    /**
+     * 通过组件名保存组件信息，通常用于存储可以在同类组件中共用的数据
+     * @param name
+     * @param json
+     */
+    static saveByName(name: string, json: string): Promise<string>;
+    static findByName<T extends WidgetData>(name: string, type: {
+        new (name: string, id?: string): T;
+    }): Promise<T | undefined>;
+    static find<T extends WidgetData>(name: string, id: string, type: {
+        new (name: string, id?: string): T;
+    }): Promise<T | undefined>;
+    private static getKey;
+}

package/dist/types/router/encoding.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Encoding Rules ␣ = Space Path: ␣ " < > # ? { } Query: ␣ " < > # & = Hash: ␣ "
+ * < > `
+ *
+ * On top of that, the RFC3986 (https://tools.ietf.org/html/rfc3986#section-2.2)
+ * defines some extra characters to be encoded. Most browsers do not encode them
+ * in encodeURI https://github.com/whatwg/url/issues/369, so it may be safer to
+ * also encode `!'()*`. Leaving un-encoded only ASCII alphanumeric(`a-zA-Z0-9`)
+ * plus `-._~`. This extra safety should be applied to query by patching the
+ * string returned by encodeURIComponent encodeURI also encodes `[\]^`. `\`
+ * should be encoded to avoid ambiguity. Browsers (IE, FF, C) transform a `\`
+ * into a `/` if directly typed in. The _backtick_ (`````) should also be
+ * encoded everywhere because some browsers like FF encode it when directly
+ * written while others don't. Safari and IE don't encode ``"<>{}``` in hash.
+ */
+export declare const PLUS_RE: RegExp;
+/**
+ * Encode characters that need to be encoded on the hash section of the URL.
+ *
+ * @param text - string to encode
+ * @returns encoded string
+ */
+export declare function encodeHash(text: string): string;
+/**
+ * Encode characters that need to be encoded query values on the query
+ * section of the URL.
+ *
+ * @param text - string to encode
+ * @returns encoded string
+ */
+export declare function encodeQueryValue(text: string | number): string;
+/**
+ * Like `encodeQueryValue` but also encodes the `=` character.
+ *
+ * @param text - string to encode
+ */
+export declare function encodeQueryKey(text: string | number): string;
+/**
+ * Encode characters that need to be encoded on the path section of the URL.
+ *
+ * @param text - string to encode
+ * @returns encoded string
+ */
+export declare function encodePath(text: string | number): string;
+/**
+ * Encode characters that need to be encoded on the path section of the URL as a
+ * param. This function encodes everything {@link encodePath} does plus the
+ * slash (`/`) character. If `text` is `null` or `undefined`, returns an empty
+ * string instead.
+ *
+ * @param text - string to encode
+ * @returns encoded string
+ */
+export declare function encodeParam(text: string | number | null | undefined): string;
+/**
+ * Decode text using `decodeURIComponent`. Returns the original text if it
+ * fails.
+ *
+ * @param text - string to decode
+ * @returns decoded string
+ */
+export declare function decode(text: string | number): string;