@steroidsjs/core 2.0.0-rc.7 → 2.0.1-beta.113

package/build/docs-autogen.js

@@ -0,0 +1,124 @@
+const path = require('path');
+const typedocModule = require('typedoc');
+const _ = require('lodash');
+const fs = require('fs');
+const {getInfo, getProperty, typeToObject, typeToString} = require('./helpers');
+
+const app = new typedocModule.Application();
+const {inputFiles} = app.bootstrap({
+    ignoreCompilerErrors: true,
+    includeDeclarations: true,
+    excludeExternals: true,
+    inputFiles: [
+        path.resolve(__dirname, '../hoc'),
+        path.resolve(__dirname, '../ui'),
+        path.resolve(__dirname, '..'),
+    ],
+    tsconfig: path.resolve(__dirname, '../tsconfig.json'),
+});
+
+const src = app.expandInputFiles(inputFiles);
+//src.push(path.resolve(__dirname, '../index.d.ts'));filesMap
+//console.log(src);
+const project = app.convert(src);
+const filesMap = {};
+project.files.forEach(file => {
+    filesMap[file.fileName] = file.fullFileName;
+})
+
+const json = project ? app.serializer.projectToObject(project) : null;
+if (!json || app.logger.hasErrors()) {
+    return;
+}
+fs.writeFileSync(path.resolve(__dirname, 'docs-autogen-raw.json'), JSON.stringify(json, null, '    '));
+//const json = JSON.parse(require('fs').readFileSync(__dirname + '/docs-autogen-raw.json'));
+
+// Store components by file path
+const components = {};
+json.children.forEach(moduleItem => {
+    if (moduleItem.kindString === 'Module' && moduleItem.flags && moduleItem.flags.isExported === true) {
+        (moduleItem.children || []).forEach(item => {
+            const moduleName = JSON.parse(moduleItem.name);
+            if (item.kindString === 'Class' && moduleItem.flags && moduleItem.flags.isExported === true) {
+                components[moduleName] = getInfo(filesMap, moduleItem, item);
+            }
+        });
+    }
+});
+
+// Store docs
+const docs = {
+    interfaces: {},
+    declarations: {},
+    demos: {},
+    components,
+};
+json.children.forEach(file => {
+    (file.children || []).forEach(item => {
+        if (item.flags && item.flags.isExported === true) {
+            if (item.kindString === 'Interface') {
+                docs.interfaces[item.name] = getInfo(filesMap, file, item);
+            }
+            if (item.kindString === 'Type alias') {
+                docs.declarations[item.name] = getProperty(item);
+            }
+        }
+    });
+
+    const demoMatch = file.name.match(/ui\/(.+)\/demo\/([^\/]+)\"$/);
+    if (demoMatch) {
+        const path = demoMatch[1].split('\/');
+        const name = demoMatch[2];
+
+        if (!file.children) {
+            let order = 0;
+            let col = null;
+            let description = null;
+            let title = null;
+
+            const fileContents = fs.readFileSync(file.originalName).toString();
+
+            const matchOrderTagPattern = /@order\s(.*)$/gmi;
+            const matchColTagPattern = /@col\s(.*)$/gmi;
+            const matchCommentPattern = /[^import]\s\*\s[^@](.*)/gmi;
+
+            const tagMatch = fileContents.match(matchOrderTagPattern);
+            if (tagMatch) {
+                order = tagMatch[0].replace('@order', '').trim();
+            }
+
+            const colMatch = fileContents.match(matchColTagPattern);
+            if (colMatch) {
+                col = colMatch[0].replace('@col', '').trim();
+            }
+
+            const commentMatch = fileContents.match(matchCommentPattern);
+            if (commentMatch) {
+                description = commentMatch.map(cm => cm.replace('*', '').trim()).join('\n')
+            }
+
+            // Store, if not empty
+            if (order > 0 || title || description) {
+                _.set(docs.demos, path.concat(name), {
+                    order,
+                    col,
+                    title,
+                    description,
+                });
+            }
+        }
+
+        // Store title, ..
+        /*const {title, description, tags} = findClassDocs(file.children);
+        if (title || description) {
+            _.set(docs.demos, path.concat(name), {
+                order: _.toInteger(tags['order']),
+                col: _.toInteger(tags['col']),
+                title,
+                description,
+            });
+        }*/
+    }
+});
+
+fs.writeFileSync(path.resolve(__dirname, 'docs-autogen-result.json'), JSON.stringify(docs, null, '    '));

package/build/helpers.js

@@ -0,0 +1,276 @@
+const path = require('path');
+const typedocModule = require('typedoc');
+const _ = require('lodash');
+const fs = require('fs');
+
+const typeToString = (type) => {
+    if (!type) {
+        return null;
+    }
+
+    switch (type.type) {
+        case 'intrinsic':
+        case 'reference':
+        case 'typeParameter':
+        case 'unknown':
+            return type.name;
+
+        case 'stringLiteral':
+            return JSON.stringify(type.value);
+
+        case 'array':
+            return typeToString(type.elementType) + '[]';
+
+        case 'tuple':
+            return (type.types || type.elements).map(subType => typeToString(subType)).join(', ');
+
+        case 'union':
+            return type.types.map(subType => typeToString(subType)).join(' | ');
+
+        case 'intersection':
+            if (type.types[0].name === 'Omit') {
+                return type.types[0].typeArguments[0].name;
+            }
+            return type.types.map(subType => typeToString(subType)).join(' & ');
+
+        case 'reflection':
+            return '{' + (type.declaration.children || []).map(d => d.name + ': ' + typeToString(d.type)).join(', ') + '}';
+    }
+
+    throw new Error('Unknown type on convert to string: ' + JSON.stringify(type));
+};
+
+const typeToObject = type => {
+    if (!type) {
+        return null;
+    }
+
+    switch (type.kindString) {
+        case 'Property':
+            return typeToObject(type.type.declaration);
+
+        case 'Function':
+            return type.name + '()';
+
+        case 'Variable':
+            try {
+                return JSON.parse(type.defaultValue);
+            } catch (e) {
+                return type.defaultValue;
+            }
+
+        case 'Type literal':
+        case 'Object literal':
+            const obj = {};
+            (type.children || []).forEach(item => {
+                obj[item.name] = typeToObject(item);
+            });
+            return obj;
+    }
+
+    throw new Error('Unknown type on convert to object: ' + JSON.stringify(type));
+};
+
+const getComment = item => {
+    return typeof item.comment === 'string'
+        ? item.comment
+        : [
+            _.get(item, 'comment.shortText'),
+            _.get(item, 'comment.text'),
+        ].filter(Boolean).join('\n\n');
+}
+
+const getTags = item => {
+    let tags = {};
+    _.get(item, 'comment.tags', []).forEach(tag => {
+        tags[tag.tag] = tag.text.trim();
+    });
+    return tags;
+};
+
+/*const findClassDocs = (children) => {
+    let title = null;
+    let description = null;
+    let tags = {};
+
+    (children || []).forEach(item => {
+        if (item.kindString === 'Class') {
+            // Get title and description
+            const commentLines = _.get(item, 'comment.shortText', '').split('\n');
+            title = commentLines.length > 0 ? commentLines.shift() : demoMatch[2];
+            description = commentLines.join('\n');
+
+            // Find order and col tags
+            let order = 0;
+            let col = null;
+            _.get(item, 'comment.tags', []).forEach(tag => {
+                tags[tag.tag] = tag.text.trim();
+            });
+        }
+    });
+
+    return {title, description, tags};
+};*/
+
+const getProperty = property => ({
+    name: property.name,
+    decorators: (property.decorators || []).map(decorator => decorator.name),
+    description: getComment(property),
+    required: !property.flags.isOptional,
+    type: typeToString(property.type),
+    example: getTags(property).example || null,
+})
+
+const getInfo = (filesMap, moduleItem, item) => {
+    if (!['Class', 'Interface', 'Type alias'].includes(item.kindString)) {
+        return null;
+    }
+
+    const moduleName = JSON.parse(moduleItem.name);
+    const commentLines = getComment(item).split('\n');
+    const info = {
+        name: item.name,
+        moduleName,
+        title: commentLines.length > 0 ? commentLines.shift() : demoMatch[2],
+        description: commentLines.join('\n'),
+        tags: getTags(item),
+    };
+
+    // Find default props for React Components
+    if (item.kindString === 'Interface') {
+        info.defaultProps = null;
+        (item.children || []).forEach(property => {
+            if (property.name === 'defaultProps' && property.flags && property.flags.isExported === true) {
+                info.defaultProps = typeToObject(property);
+            }
+        });
+        (moduleItem.children || []).forEach(item => {
+            if (item.kindString === 'Object literal' && item.name === 'defaultProps' && item.flags && item.flags.isConst === true) {
+                info.defaultProps = {
+                    ...info.defaultProps,
+                    ...typeToObject(item),
+                };
+            }
+        });
+
+        info.extends = null;
+        if (filesMap[item.sources[0].fileName]) {
+            const source = fs.readFileSync(filesMap[item.sources[0].fileName]);
+            const extendsMatch = String(source).match(new RegExp(`interface\\s+${item.name}\\s+extends([^{]+)`));
+            info.extends = extendsMatch ? extendsMatch[1].split(',').map(name => name.trim()) : [];
+        }
+    }
+
+    // Get properties
+    if (['Class', 'Interface'].includes(item.kindString)) {
+        info.properties = (item.children || [])
+            .map(property => {
+                // Check is property
+                if (property.kindString !== 'Property') {
+                    return false;
+                }
+
+                const propertyInfo = getProperty(property);
+
+                // Skip props without jsoc for components
+                if (!propertyInfo.description && moduleName.match(/^components\//)) {
+                    return false;
+                }
+
+                return propertyInfo;
+            })
+            .filter(Boolean);
+    }
+
+    // Get methods
+    if (item.kindString === 'Class') {
+        info.methods = (item.children || [])
+            .map(method => {
+                // Check is property
+                if (method.kindString !== 'Method') {
+                    return false;
+                }
+
+                /*
+                    "signatures": [
+                        {
+                            "id": 7631,
+                            "name": "moment",
+                            "kind": 4096,
+                            "kindString": "Call signature",
+                            "flags": {
+                                "isExported": true
+                            },
+                            "comment": {
+                                "shortText": "Получение экземпляра `moment` с учетом временной зоны бекенда"
+                            },
+                            "parameters": [
+                                {
+                                    "id": 7632,
+                                    "name": "date",
+                                    "kind": 32768,
+                                    "kindString": "Parameter",
+                                    "flags": {
+                                        "isExported": true
+                                    },
+                                    "comment": {},
+                                    "type": {
+                                        "type": "intrinsic",
+                                        "name": "any"
+                                    },
+                                    "defaultValue": "undefined"
+                                },
+                                {
+                                    "id": 7633,
+                                    "name": "format",
+                                    "kind": 32768,
+                                    "kindString": "Parameter",
+                                    "flags": {
+                                        "isExported": true
+                                    },
+                                    "comment": {
+                                        "text": "\n"
+                                    },
+                                    "type": {
+                                        "type": "intrinsic",
+                                        "name": "any"
+                                    },
+                                    "defaultValue": "undefined"
+                                }
+                            ],
+                            "type": {
+                                "type": "intrinsic",
+                                "name": "any"
+                            }
+                        }
+                    ],
+                 */
+
+                if (!method.signatures || method.signatures.length === 0) {
+                    return false;
+                }
+
+                const methodInfo = getProperty(method.signatures[0]);
+
+                // Skip props without jsoc for components
+                if (!methodInfo.description && moduleName.match(/^components\//)) {
+                    return false;
+                }
+
+                return {
+                    ...methodInfo,
+                    parameters: (method.signatures[0].parameters || []).map(param => getProperty(param)),
+                };
+            })
+            .filter(Boolean);
+    }
+
+    return info;
+};
+
+module.exports = {
+    getInfo,
+    getProperty,
+    typeToObject,
+    typeToString,
+};

package/components/ClientStorageComponent.ts

@@ -0,0 +1,117 @@
+import * as cookie from 'js-cookie';
+
+/**
+ * Client Storage Component
+ * Слой хранения данных в браузере (cookie, local/session storage) или ReactNative
+ */
+export default class ClientStorageComponent {
+    STORAGE_COOKIE: string;
+    STORAGE_LOCAL: any;
+    STORAGE_SESSION: any;
+    cookieAvailable: any;
+    localStorageAvailable: boolean;
+    sessionStorageAvailable: boolean;
+
+    constructor(components) {
+        this.localStorageAvailable = !process.env.IS_SSR;
+        this.sessionStorageAvailable = !process.env.IS_SSR;
+        this.cookieAvailable = !process.env.IS_SSR;
+        this.STORAGE_SESSION = 'session';
+        this.STORAGE_LOCAL = 'local';
+        this.STORAGE_COOKIE = 'cookie';
+        if (this.localStorageAvailable) {
+            try {
+                window.localStorage.setItem('localStorageAvailable', '1');
+                this.localStorageAvailable = window.localStorage.getItem('localStorageAvailable') === '1';
+                window.localStorage.removeItem('localStorageAvailable');
+            } catch (e) {
+                this.localStorageAvailable = false;
+            }
+        }
+        if (this.sessionStorageAvailable) {
+            try {
+                window.sessionStorage.setItem('sessionStorageAvailable', '1');
+                this.sessionStorageAvailable = window.localStorage.getItem('sessionStorageAvailable') === '1';
+                window.sessionStorage.removeItem('sessionStorageAvailable');
+            } catch (e) {
+                this.sessionStorageAvailable = false;
+            }
+        }
+    }
+
+    /**
+     * @param {string} name
+     * @param {string} [storageName]
+     * @returns {*}
+     */
+    get(name, storageName) {
+        storageName = storageName || this.STORAGE_LOCAL;
+        if (this.localStorageAvailable && storageName === this.STORAGE_LOCAL) {
+            return window.localStorage.getItem(name);
+        } else if (
+            this.sessionStorageAvailable &&
+            storageName === this.STORAGE_SESSION
+        ) {
+            return window.sessionStorage.getItem(name);
+        } else if (this.cookieAvailable) {
+            return cookie.get(name);
+        }
+        return null;
+    }
+
+    /**
+     * @param {string} name
+     * @param {*} value
+     * @param {string} [storageName]
+     * @param {number|null} [expires]
+     */
+    set(name, value, storageName, expires = null) {
+        storageName = storageName || this.STORAGE_LOCAL;
+        if (this.localStorageAvailable && storageName === this.STORAGE_LOCAL) {
+            window.localStorage.setItem(name, value);
+        } else if (
+            this.sessionStorageAvailable &&
+            storageName === this.STORAGE_SESSION
+        ) {
+            window.sessionStorage.setItem(name, value);
+        } else if (this.cookieAvailable) {
+            cookie.set(name, value, {
+                expires,
+                domain: this._getDomain()
+            });
+        }
+    }
+
+    /**
+     *
+     * @param {string} name
+     * @param {string} [storageName]
+     */
+    remove(name, storageName) {
+        storageName = storageName || this.STORAGE_LOCAL;
+        if (this.localStorageAvailable && storageName === this.STORAGE_LOCAL) {
+            window.localStorage.removeItem(name);
+        } else if (
+            this.sessionStorageAvailable &&
+            storageName === this.STORAGE_SESSION
+        ) {
+            window.sessionStorage.removeItem(name);
+        } else if (this.cookieAvailable) {
+            cookie.remove(name, {
+                domain: this._getDomain()
+            });
+        }
+    }
+
+    _getDomain() {
+        const host = (typeof location !== 'undefined' && location.hostname) || '';
+        return (
+            (!/\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/.test(host) &&
+                host
+                    .split('.')
+                    .slice(-2)
+                    .join('.')) ||
+            host
+        );
+    }
+}

package/components/HtmlComponent.ts

@@ -0,0 +1,77 @@
+import _isString from 'lodash-es/isString';
+
+/**
+ * Html Component
+ * Хелпер для работы с БЭМ классами и DOM элементами
+ */
+export default class HtmlComponent {
+    namespace = '';
+
+    constructor(components) {
+    }
+
+    bem(blockName) {
+        const bem = (...names) => this.classNames(...names);
+        bem.block = modifiers => this._applyModifiers(blockName, modifiers);
+        bem.element = (elementName, modifiers) => this._applyModifiers(blockName + '__' + elementName, modifiers);
+        return bem;
+    }
+
+    classNames(...names) {
+        return Array.prototype.slice
+            .call(names)
+            .filter(v => v)
+            .join(' ');
+    }
+
+    addClass(node, className) {
+        if (node && _isString(node.className)) {
+            const classes = node.className.split(' ');
+            if (classes.indexOf(className) === -1) {
+                classes.push(className);
+                node.className = classes.join(' ');
+            }
+        }
+    }
+
+    removeClass(node, className) {
+        if (node && _isString(node.className)) {
+            const classes = node.className.split(' ');
+            const index = classes.indexOf(className);
+            if (index !== -1) {
+                classes.splice(index, 1);
+                node.className = classes.join(' ');
+            }
+        }
+    }
+
+    closest(element, className) {
+        while ((element = element.parentElement)
+        && !element.classList.contains(className)) {
+        } // eslint-disable-line no-empty
+        return element;
+    }
+
+    _applyModifiers(entity, modifiers) {
+        let result = [];
+        result.push(entity);
+        if (typeof modifiers === 'string') {
+            result.push(entity + (modifiers ? '_' + modifiers : ''));
+        } else if (modifiers) {
+            Object.keys(modifiers).forEach(key => {
+                const value = modifiers[key];
+                if (!value) {
+                    // Skip
+                } else if (value === true) {
+                    result.push(entity + '_' + key);
+                } else {
+                    result.push(entity + '_' + key + '_' + value);
+                }
+            });
+        }
+
+        // Append namespace
+        result = result.map(cl => this.namespace + cl);
+        return result.join(' ');
+    }
+}