structured-fw 0.7.2

package/build/app/routes/Test.js

@@ -0,0 +1,101 @@
+import { Document } from '../../system/server/Document.js';
+import { Request } from '../../system/server/Request.js';
+export default function (app) {
+    app.request.on('GET', '/test/form', async (ctx) => {
+        const doc = new Document(app, 'Form test', ctx);
+        await doc.loadComponent('FormTestNested', { test: 3 });
+        ctx.respondWith(doc);
+    });
+    app.request.on('POST', '/test/form', async (ctx) => {
+        console.log(JSON.stringify(ctx.body, undefined, 4));
+        const userImage = ctx.files.user.image[0];
+        ctx.response.setHeader('Content-Type', userImage.type);
+        ctx.respondWith(userImage.data);
+    });
+    app.request.on('GET', '/test/client_import', async (ctx) => {
+        const doc = new Document(app, 'Test', ctx);
+        await doc.loadComponent('ClientImport', { xyz: 10, asd: 12 });
+        ctx.respondWith(doc);
+    });
+    app.request.on('GET', '/test/redraw', async (ctx) => {
+        const doc = new Document(app, 'Test', ctx);
+        await doc.loadComponent('RedrawAbort');
+        ctx.respondWith(doc);
+    });
+    app.request.on('GET', '/test/models', async (ctx) => {
+        const doc = new Document(app, 'Test', ctx);
+        await doc.loadComponent('ModelsTest');
+        ctx.respondWith(doc);
+    });
+    app.request.on('GET', '/getargs', async (ctx) => {
+        ctx.respondWith(ctx.getArgs);
+    });
+    app.request.on('GET', '/form/multipart', async (ctx) => {
+        const doc = new Document(app, 'Test multipart form', ctx);
+        await doc.loadComponent('MultipartForm');
+        ctx.respondWith(doc);
+    });
+    app.request.on('POST', '/form/multipart', async (ctx) => {
+        console.log(ctx.files);
+        ctx.respondWith(ctx.body);
+    });
+    app.request.on('GET', '/conditional', async (ctx) => {
+        const doc = new Document(app, 'Test multipart form', ctx);
+        await doc.loadComponent('Conditionals');
+        ctx.respondWith(doc);
+    });
+    app.request.on('GET', '/urldecode', async (ctx) => {
+        const noVal = 'noVal';
+        const noValNested = 'filters[beds][min]';
+        const simple = 'simple=2';
+        const simpleObj = 'person[name]=fname&person[last_name]=lname';
+        const simpleArray = 'colors[]=red&colors[]=blue';
+        const orderedArray = 'colorsOrdered[1]=red&colorsOrdered[0]=blue';
+        const indexedArray = 'months[0]=Jan&months[1]=Feb&months[2]=Mar';
+        const arrayOfObjects = 'users[0][name]=John&users[0][email]=johndoe@gmail.com&users[1][name]=Tim&users[1][email]=tim@gmail.com';
+        const objectWithArrayValues = 'user[name]=John&user[last_name]=Doe&user[sports][]=table tennis&user[sports][]=football';
+        const objectWithObjectValues = 'data[paper][props][size]=10x13&data[paper][props][type]=matte';
+        const nestedArraySimple = 'colorStack[0][]=red&colorStack[0][]=blue&colorStack[1][]=green';
+        const arrayOfObjectsWithArrayValues = 'usersArr[0][name]=John&usersArr[0][email]=johndoe@gmail.com&usersArr[0][sports][]=football&usersArr[0][sports][]=basketball&usersArr[1][name]=Too&usersArr[1][email]=tootoo@gmail.com&usersArr[1][sports][]=bocce&usersArr[1][sports][]=cricket&usersArr[1][sports][]=dancing';
+        const missingValue = 'missing=';
+        const missingArrayValue = 'missingArr[]=';
+        const objBlankValue = `objBlank[0][email]=`;
+        const spaces = `spaces=value%20with%20spaces`;
+        const special = `garbage=` + encodeURIComponent('value!@#&$%^*()');
+        const nonLatin = `key3=` + encodeURIComponent('привет');
+        const t = new Date().getTime();
+        const test = Request.queryStringDecode([noVal, noValNested, simple, simpleObj, simpleArray, orderedArray, indexedArray, arrayOfObjects, objectWithArrayValues, objectWithObjectValues, nestedArraySimple, arrayOfObjectsWithArrayValues, missingValue, nonLatin, spaces, special, objBlankValue, missingArrayValue, simple].join('&'));
+        const dur = new Date().getTime() - t;
+        console.log(dur);
+        ctx.respondWith(test);
+    });
+    app.request.on('GET', '/client_import', async (ctx) => {
+        const doc = new Document(app, 'Test multipart form', ctx);
+        await doc.loadComponent('ClientImport');
+        doc.head.add(`
+        <script type="importmap">
+        {
+            imports: {
+                'components/*' : '/build/app/views/components/*'
+            }
+        }
+        </script>
+        `);
+        ctx.respondWith(doc);
+    });
+    app.request.on('GET', '/serverclass', async (ctx) => {
+        const doc = new Document(app, 'Test multipart form', ctx);
+        await doc.loadComponent('ServerSideContext');
+        ctx.respondWith(doc);
+    });
+    app.request.on('GET', '/routes/new', async (ctx) => {
+        const doc = new Document(app, 'Test multipart form', ctx);
+        await doc.loadComponent('Conditionals');
+        return doc;
+    });
+    app.request.on('GET', '/passObj', async (ctx) => {
+        const doc = new Document(app, 'Test pass obj', ctx);
+        await doc.loadComponent('PassObject');
+        ctx.respondWith(doc);
+    });
+}

package/build/app/routes/Todo.js

@@ -0,0 +1 @@
+"use strict";

package/build/app/routes/Upload.js

@@ -0,0 +1 @@
+"use strict";

package/build/app/routes/Validation.d.ts

@@ -0,0 +1,2 @@
+import { Application } from "../../system/server/Application.js";
+export default function (app: Application): void;

package/build/app/routes/Validation.js

@@ -0,0 +1,34 @@
+import { FormValidation } from '../../system/server/FormValidation.js';
+import { Document } from "../../system/server/Document.js";
+export default function (app) {
+    let validator = new FormValidation();
+    validator.singleError = true;
+    validator.addRule('name', 'Name', ['required', ['minLength', 3]]);
+    validator.addRule('email', 'Email', ['validEmail']);
+    validator.addRule('number', 'Number', ['number', 'required']);
+    validator.addRule('numeric', 'Numeric', ['numeric', 'required']);
+    validator.addRule('float', 'Float', ['float', 'required']);
+    app.request.on('POST', '/validation', async (ctx) => {
+        if (ctx.body) {
+            let validationResult = await validator.validate(ctx.body);
+            if (validationResult.valid) {
+                ctx.response.write('Valid');
+            }
+            else {
+                app.session.setValue(ctx.sessionId, 'validationErrors', validationResult.errors);
+                app.session.setValue(ctx.sessionId, 'formValues', ctx.body);
+                app.request.redirect(ctx.response, '/validation');
+            }
+        }
+    });
+    app.request.on('GET', '/validation', async (ctx) => {
+        let doc = new Document(app, 'Form validation');
+        await doc.loadView('pages/validation', app.session.extract(ctx.sessionId, [
+            { validationErrors: 'errors' },
+            { formValues: 'values' }
+        ]));
+        ctx.response.write(doc.toString());
+        app.session.removeValue(ctx.sessionId, 'validationErrors');
+        app.session.removeValue(ctx.sessionId, 'formValues');
+    });
+}

package/build/app/views/components/ClientImport/ClientImport.client.d.ts

@@ -0,0 +1,2 @@
+import { InitializerFunction } from '../../../../system/Types.js';
+export declare const init: InitializerFunction;

package/build/app/views/components/ClientImport/ClientImport.client.js

@@ -0,0 +1,4 @@
+export const init = async function () {
+    const test = await import('/assets/ts/Export.js');
+    console.log(test);
+};

package/build/app/views/components/ClientImport/Export.d.ts

@@ -0,0 +1 @@
+export declare const test = 1;

package/build/app/views/components/ClientImport/Export.js

@@ -0,0 +1 @@
+export const test = 1;

package/build/app/views/components/Conditionals/Conditionals.client.d.ts

@@ -0,0 +1,2 @@
+import { InitializerFunction } from '../../../../system/Types.js';
+export declare const init: InitializerFunction;

package/build/app/views/components/Conditionals/Conditionals.client.js

@@ -0,0 +1,43 @@
+export const init = async function () {
+    const style = document.createElement('style');
+    style.type = 'text/css';
+    style.textContent = `
+        .active {
+            font-weight: 800;
+        }
+    `;
+    document.head.appendChild(style);
+    this.store.set('showMessage', false);
+    this.bind(this.ref('setShowMessage'), 'click', () => {
+        this.store.set('showMessage', true);
+    });
+    this.bind(this.ref('unsetShowMessage'), 'click', () => {
+        this.store.set('showMessage', false);
+    });
+    let num = 0;
+    const increaseNum = () => {
+        num++;
+        setNum();
+    };
+    const decreaseNum = () => {
+        num--;
+        setNum();
+    };
+    const setNum = () => {
+        this.store.set('number', num);
+        this.ref('num').textContent = num.toString();
+    };
+    this.bind(this.ref('numIncrease'), 'click', () => {
+        increaseNum();
+    });
+    this.bind(this.ref('numDecrease'), 'click', () => {
+        decreaseNum();
+    });
+    setNum();
+    this.conditionalCallback('method1', () => {
+        return this.store.get('showMessage') === true && num > 3;
+    });
+    this.conditionalCallback('method2', (number) => {
+        return number === num;
+    });
+};

package/build/app/views/components/FormTest/FormTestNested/FormTestNested.d.ts

@@ -0,0 +1,8 @@
+import { ComponentScaffold, RequestContext } from '../../../../../system/Types.js';
+type ComponentData = {
+    test: number;
+};
+export default class FormTestNested implements ComponentScaffold {
+    getData(data: ComponentData, ctx: RequestContext): Promise<ComponentData>;
+}
+export {};

package/build/app/views/components/FormTest/FormTestNested/FormTestNested.js

@@ -0,0 +1,7 @@
+export default class FormTestNested {
+    async getData(data, ctx) {
+        return {
+            test: 123
+        };
+    }
+}

package/build/app/views/components/ModelsTest/ModelsTest.client.d.ts

@@ -0,0 +1,2 @@
+import { InitializerFunction } from '../../../../system/Types.js';
+export declare const init: InitializerFunction;

package/build/app/views/components/ModelsTest/ModelsTest.client.js

@@ -0,0 +1,5 @@
+export const init = async function () {
+    this.store.onChange('test', (key, val) => {
+        this.find('ModelTestNested')?.redraw(this.getData());
+    });
+};

package/build/app/views/components/MultipartForm/MultipartForm.client.js

@@ -0,0 +1 @@
+"use strict";

package/build/app/views/components/PassObject/PassObject.d.ts

@@ -0,0 +1,10 @@
+import { ComponentScaffold, RequestContext } from '../../../../system/Types.js';
+type ComponentData = {};
+export default class PassObj implements ComponentScaffold {
+    getData(data: ComponentData, ctx: RequestContext): Promise<{
+        obj: {
+            uuid: string;
+        };
+    }>;
+}
+export {};

package/build/app/views/components/PassObject/PassObject.js

@@ -0,0 +1,10 @@
+import { randomString } from '../../../../system/Util.js';
+export default class PassObj {
+    async getData(data, ctx) {
+        return {
+            obj: {
+                uuid: randomString(12)
+            }
+        };
+    }
+}

package/build/app/views/components/PassObject/ReceiveObj/ReceiveObj.d.ts

@@ -0,0 +1,6 @@
+import { ComponentScaffold, RequestContext } from '../../../../../system/Types.js';
+type ComponentData = {};
+export default class ReceiveObj implements ComponentScaffold {
+    getData(data: ComponentData, ctx: RequestContext): Promise<ComponentData>;
+}
+export {};

package/build/app/views/components/PassObject/ReceiveObj/ReceiveObj.js

@@ -0,0 +1,6 @@
+export default class ReceiveObj {
+    async getData(data, ctx) {
+        console.log('a', data);
+        return data;
+    }
+}

package/build/app/views/components/RedrawAbort/RedrawAbort.client.d.ts

@@ -0,0 +1,2 @@
+import { InitializerFunction } from '../../../../system/Types.js';
+export declare const init: InitializerFunction;

package/build/app/views/components/RedrawAbort/RedrawAbort.client.js

@@ -0,0 +1,6 @@
+export const init = async function () {
+    setTimeout(() => {
+        this.redraw();
+        this.redraw();
+    }, 1000);
+};

package/build/app/views/components/RedrawAbort/RedrawAbort.d.ts

@@ -0,0 +1,8 @@
+import { ComponentScaffold, RequestContext } from '../../../../system/Types.js';
+type ComponentData = {};
+export default class RedrawAbort implements ComponentScaffold {
+    getData(data: ComponentData, ctx: RequestContext): Promise<{
+        key: string;
+    }>;
+}
+export {};

package/build/app/views/components/RedrawAbort/RedrawAbort.js

@@ -0,0 +1,8 @@
+import { randomString } from '../../../../system/Util.js';
+export default class RedrawAbort {
+    async getData(data, ctx) {
+        return {
+            key: randomString(5)
+        };
+    }
+}

package/build/app/views/components/ServerSideContext/ServerSideContext.d.ts

@@ -0,0 +1,7 @@
+import { ComponentScaffold } from '../../../../system/Types.js';
+export default class ServerSideContext implements ComponentScaffold {
+    getData(): Promise<{
+        number: number;
+    }>;
+    num(): number;
+}

package/build/app/views/components/ServerSideContext/ServerSideContext.js

@@ -0,0 +1,10 @@
+export default class ServerSideContext {
+    async getData() {
+        return {
+            number: this.num()
+        };
+    }
+    num() {
+        return Math.floor(Math.random() * 100);
+    }
+}

package/build/assets/ts/Export.d.ts

@@ -0,0 +1 @@
+export declare const test: number;

package/build/assets/ts/Export.js

@@ -0,0 +1 @@
+export const test = 123;

package/build/index.d.ts

@@ -0,0 +1 @@
+export {};

package/build/index.js

@@ -0,0 +1,3 @@
+import { Application } from "@structured/Application.js";
+import { config } from './Config.js';
+new Application(config);

package/build/system/Helpers.d.ts

@@ -0,0 +1,3 @@
+import { HelperDelegate } from "handlebars";
+declare const helpers: Record<string, HelperDelegate>;
+export default helpers;

package/build/system/Helpers.js

@@ -0,0 +1,72 @@
+import { attributeValueToString, objectEach } from "./Util.js";
+const helpers = {
+    htmlTag: function (...args) {
+        return `<${args[0]}></${args[0]}>`;
+    },
+    layoutComponent: function (...args) {
+        if (args.length < 2 || args.length > 4) {
+            console.warn('layoutComponent expects 1 - 3 arguments (componentName, data?, attributes?) got ' + (args.length - 1));
+        }
+        const argsUsed = args.slice(0, args.length - 1);
+        const componentName = argsUsed[0];
+        const data = argsUsed[1];
+        const attributes = argsUsed[2];
+        const dataAttributes = [];
+        let attributesString = '';
+        if (attributes) {
+            if (attributes) {
+                const attrNames = Object.keys(attributes);
+                attributesString = attrNames.map((attrName) => {
+                    const val = attributes[attrName];
+                    if (typeof val === 'string' || typeof val === 'number') {
+                        return `${attrName}="${val}"`;
+                    }
+                    if (val === true) {
+                        return attrName;
+                    }
+                    return null;
+                }).filter((val) => val !== null).join(' ');
+            }
+        }
+        if (data) {
+            objectEach(data, (key, val) => {
+                dataAttributes.push(`data-${key}="${attributeValueToString(key, val)}"`);
+            });
+        }
+        return `<${componentName} ${dataAttributes.length > 0 ? dataAttributes.join(' ') : ''} ${attributesString}></${componentName}>`;
+    },
+    json: function (...args) {
+        if (args.length > 1) {
+            if (typeof args[0] === 'object' && args[0] !== null) {
+                return JSON.stringify(args[0]);
+            }
+            return '';
+        }
+        return '';
+    },
+    attr: function (key, val) {
+        return `data-${key}="${attributeValueToString(key, val)}"`;
+    },
+    nl2br: function (...args) {
+        if (args.length === 1 && 'fn' in args[0]) {
+            return (args[0].fn(this) || '').replaceAll('\n', '<br>');
+        }
+        if (args.length === 2) {
+            if (typeof args[0] !== 'string') {
+                return '';
+            }
+            return args[0].replaceAll('\n', '<br>');
+        }
+        return '';
+    },
+    indent: function (...args) {
+        if (args.length === 1 && 'fn' in args[0]) {
+            return args[0].fn(this).replaceAll(' ', '&nbsp;').replaceAll('\t', '&nbsp;'.repeat(4));
+        }
+        if (args.length === 2) {
+            return args[0].replaceAll(' ', '&nbsp;').replaceAll('\t', '&nbsp;'.repeat(4));
+        }
+        return '';
+    }
+};
+export default helpers;

package/build/system/Symbols.d.ts

@@ -0,0 +1,3 @@
+export declare const symbolSession: unique symbol;
+export declare const symbolAny: unique symbol;
+export declare const symbolArrays: unique symbol;

package/build/system/Symbols.js

@@ -0,0 +1,3 @@
+export const symbolSession = Symbol('session');
+export const symbolAny = Symbol('*');
+export const symbolArrays = Symbol.for('arrays');

package/build/system/Types.d.ts

@@ -0,0 +1,171 @@
+import { IncomingMessage, ServerResponse } from "node:http";
+import { Application } from "./server/Application.js";
+import { symbolArrays } from "./Symbols.js";
+import { RequestContextData } from "../app/Types.js";
+import { Net } from './client/Net.js';
+import { ClientComponent } from './client/ClientComponent.js';
+import { Component } from "./server/Component.js";
+export type StructuredConfig = {
+    readonly envPrefix?: string;
+    readonly autoInit: boolean;
+    url: {
+        removeTrailingSlash: boolean;
+        componentRender: false | string;
+        isAsset: (url: string) => boolean;
+    };
+    routes: {
+        readonly path: string;
+    };
+    components: {
+        readonly path: string;
+        readonly componentNameAttribute: string;
+    };
+    session: {
+        readonly cookieName: string;
+        readonly keyLength: number;
+        readonly durationSeconds: number;
+        readonly garbageCollectIntervalSeconds: number;
+        readonly garbageCollectAfterSeconds: number;
+    };
+    http: {
+        host?: string;
+        port: number;
+        linkHeaderRel: 'preload' | 'preconnect';
+    };
+    readonly runtime: 'Node.js' | 'Deno';
+};
+export type StructuredClientConfig = {
+    componentRender: StructuredConfig['url']['componentRender'];
+    componentNameAttribute: string;
+};
+export type RequestMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+export type RequestCallback = (ctx: RequestContext) => Promise<any>;
+export type RequestHandler = {
+    match: Array<URISegmentPattern> | RegExp;
+    methods: Array<RequestMethod>;
+    callback: RequestCallback;
+    scope: any;
+    staticAsset: boolean;
+};
+export type RequestContext = {
+    request: IncomingMessage;
+    response: ServerResponse;
+    args: URIArguments;
+    handler: null | RequestHandler;
+    cookies: Record<string, string>;
+    body?: PostedDataDecoded;
+    bodyRaw?: Buffer;
+    files?: Record<string, RequestBodyRecordValue>;
+    data: RequestContextData;
+    sessionId?: string;
+    isAjax: boolean;
+    getArgs: PostedDataDecoded;
+    respondWith: (data: any) => void;
+    redirect: (to: string, statusCode?: number) => void;
+    show404: () => Promise<void>;
+};
+export type PostedDataDecoded = Record<string, string | boolean | Array<string | boolean | PostedDataDecoded> | Record<string, string | boolean | Array<string | boolean | PostedDataDecoded>> | Record<string, string | boolean | Array<string | boolean>>>;
+export type RequestBodyRecordValue = string | Array<RequestBodyRecordValue> | {
+    [key: string]: RequestBodyRecordValue;
+} | {
+    [key: string]: RequestBodyFile;
+} | Array<RequestBodyFile> | RequestBodyFile;
+export interface RequestBodyArguments {
+    [key: string]: RequestBodyRecordValue;
+    [symbolArrays]?: {
+        [key: string]: Array<string>;
+    };
+}
+export type RequestBodyFiles = {
+    [key: string]: RequestBodyFile;
+};
+export type RequestBodyFile = {
+    fileName: string;
+    data: Buffer;
+    type: string;
+};
+export type URISegmentPattern = {
+    pattern: string | RegExp;
+    name?: string;
+    type?: 'string' | 'number';
+};
+export type URIArguments = {
+    [key: string]: string | number | RegExpExecArray;
+};
+export type DocumentResource = {
+    path: string;
+    attributes: Record<string, string | null>;
+    priority: number;
+};
+export type ComponentEntry = {
+    name: string;
+    path: {
+        absolute: string;
+        relative: string;
+        relativeToViews: string;
+        build: string;
+        html: string;
+        jsServer?: string;
+        jsClient?: string;
+    };
+    hasJS: boolean;
+    html: string;
+    static: boolean;
+    module?: ComponentScaffold;
+    renderTagName?: string;
+    exportData: boolean;
+    exportFields?: Array<string>;
+    attributes?: Record<string, string>;
+    initializer?: InitializerFunction;
+};
+export interface ComponentScaffold {
+    tagName?: string;
+    exportData?: boolean;
+    exportFields?: Array<string>;
+    static?: boolean;
+    deferred?: (data: Record<string, any>, ctx: RequestContext | undefined, app: Application) => boolean;
+    attributes?: Record<string, string>;
+    getData: (this: ComponentScaffold, data: RequestBodyArguments | LooseObject, ctx: undefined | RequestContext, app: Application, component: Component) => Promise<LooseObject | null>;
+    [key: string]: any;
+}
+export type LooseObject = Record<string, any>;
+export type ApplicationEvents = 'serverStarted' | 'beforeRequestHandler' | 'afterRequestHandler' | 'beforeRoutes' | 'afterRoutes' | 'beforeComponentLoad' | 'afterComponentLoad' | 'documentCreated' | 'beforeAssetAccess' | 'afterAssetAccess' | 'pageNotFound';
+export type SessionEntry = {
+    sessionId: string;
+    lastRequest: number;
+    data: LooseObject;
+};
+export type ValidationRuleWithArguments = [string, any];
+export type FormValidationEntry = {
+    field: [string, string];
+    rules: Array<string | ValidationRuleWithArguments | ValidatorFunction>;
+};
+export type ValidatorFunction = (data: PostedDataDecoded, field: string, arg: number, rules: Array<string | ValidationRuleWithArguments | ValidatorFunction>) => Promise<boolean>;
+export type ValidatorErrorDecorator = (fieldHumanReadable: string, data: PostedDataDecoded, field: string, arg: any) => string | Promise<string>;
+export type ValidationErrors = {
+    [field: string]: Array<string>;
+};
+export type ValidationErrorsSingle = {
+    [field: string]: string;
+};
+export type ValidationResult = {
+    valid: boolean;
+    errors: ValidationErrors | ValidationErrorsSingle;
+};
+export type InitializerFunction = (this: ClientComponent, ctx: InitializerFunctionContext) => Promise<void>;
+export type Initializers = {
+    [key: string]: InitializerFunction;
+};
+export type InitializerFunctionContext = {
+    net: Net;
+    isRedraw: boolean;
+};
+export type StoreChangeCallback = (key: string, value: any, oldValue: any, componentId: string) => void;
+export type AsteriskAny = '*';
+export type ClientComponentTransition = {
+    fade: false | number;
+    slide: false | number;
+};
+export type ClientComponentTransitionEvent = 'show' | 'hide';
+export type ClientComponentTransitions = Record<ClientComponentTransitionEvent, ClientComponentTransition>;
+export type EventEmitterCallback = (payload: any) => void;

package/build/system/Types.js

@@ -0,0 +1 @@
+import { symbolArrays } from "./Symbols.js";

package/build/system/Util.d.ts

@@ -0,0 +1,20 @@
+import { LooseObject, PostedDataDecoded } from "./Types.js";
+export declare function queryStringDecode(queryString: string, initialValue?: PostedDataDecoded, trimValues?: boolean): PostedDataDecoded;
+export declare function queryStringDecodedSetValue(obj: PostedDataDecoded | string, value: any): LooseObject;
+export declare function objectEach<T>(obj: T, callbackEach: (key: keyof T, value: T[keyof T]) => void): void;
+export declare function toCamelCase(dataKey: string, separator?: string): string;
+export declare function toSnakeCase(str: string, joinWith?: string): string;
+export declare function capitalize(str: string): string;
+export declare function isAsync(fn: Function): boolean;
+export declare function randomString(len: number): string;
+export declare function unique<T>(arr: Array<T>): Array<T>;
+export declare function stripTags(contentWithHTML: string, keepTags?: Array<string>): string;
+export declare function attributeValueToString(key: string, value: any): string;
+export declare function attributeValueFromString(attributeValue: string): string | {
+    key: string;
+    value: any;
+};
+export declare function attributeValueEscape(str: string): string;
+export declare function isObject(item: any): boolean;
+export declare function equalDeep(a: LooseObject, b: LooseObject): boolean;
+export declare function mergeDeep(target: any, ...sources: Array<any>): LooseObject;