isomorfeus-preact 10.5.0 → 10.5.4

data/node_modules/nano-css/addon/vcssom/cssToTree.d.ts

@@ -0,0 +1,15 @@
+import {CssLikeObject} from '../../types/common';
+
+export interface Css {
+    [key: string]: CssLikeObject[keyof CssLikeObject] | Css;
+}
+
+export interface Tree {
+    [atRulePrelude: string]: {
+        [selector: string]: {
+            [property: string]: CssLikeObject;
+        };
+    };
+}
+
+export function cssToTree(tree: {}, css: Css, selector: string, prelude: string): Tree;

data/node_modules/nano-css/addon/vcssom/cssToTree.js

@@ -0,0 +1,42 @@
+function cssToTree (tree, css, selector, prelude) {
+    var declarations = {};
+    var hasDeclarations = false;
+    var key, value;
+
+    for (key in css) {
+        value = css[key];
+        if (typeof value !== 'object') {
+            hasDeclarations = true;
+            declarations[key] = value;
+        }
+    }
+
+    if (hasDeclarations) {
+        if (!tree[prelude]) tree[prelude] = {};
+        tree[prelude][selector] = declarations;
+    }
+
+    for (key in css) {
+        value = css[key];
+        if (typeof value === 'object') {
+            if (key[0] === '@') {
+                cssToTree(tree, value, selector, key);
+            } else {
+                var hasCurrentSymbol = key.indexOf('&') > -1;
+                var selectorParts = selector.split(',');
+                if (hasCurrentSymbol) {
+                    for (var i = 0; i < selectorParts.length; i++) {
+                        selectorParts[i] = key.replace(/&/g, selectorParts[i]);
+                    }
+                } else {
+                    for (var i = 0; i < selectorParts.length; i++) {
+                        selectorParts[i] = selectorParts[i] + ' ' + key;
+                    }
+                }
+                cssToTree(tree, value, selectorParts.join(','), prelude);
+            }
+        }
+    }
+};
+
+exports.cssToTree = cssToTree;

data/node_modules/nano-css/addon/vcssom/removeRule.d.ts

@@ -0,0 +1,3 @@
+import {CSSOMRule} from '../cssom';
+
+export function removeRule(sh: CSSStyleSheet, rule: CSSOMRule);

data/node_modules/nano-css/addon/vcssom/removeRule.js

@@ -0,0 +1,15 @@
+function removeRule (rule) {
+    var maxIndex = rule.index;
+    var sh = rule.parentStyleSheet;
+    var rules = sh.cssRules || sh.rules;
+    maxIndex = Math.max(maxIndex, rules.length - 1);
+    while (maxIndex >= 0) {
+        if (rules[maxIndex] === rule) {
+            sh.deleteRule(maxIndex);
+            break;
+        }
+        maxIndex--;
+    }
+}
+
+exports.removeRule = removeRule;

data/node_modules/nano-css/addon/vcssom.d.ts

@@ -0,0 +1,72 @@
+import {CSSOMAddon} from './cssom';
+import {Css} from './vcssom/cssToTree';
+import {NanoRenderer} from '../types/nano';
+import {CSSOMRule} from './cssom';
+import {CssProps} from '../types/common';
+
+export interface VRule {
+    /**
+     * CSS declarations, like `{color: 'red'}`
+     */
+    decl: CssProps;
+    rule: CSSOMRule;
+
+    /**
+     * Re-render css rule according to new CSS declarations.
+     * @param decl CSS declarations, like `{color: 'red'}`
+     */
+    diff(decl: CssProps);
+
+    /**
+     * Removes this `VRule` from CSSOM. After calling this method, you
+     * cannot call `diff` anymore as this rule will be removed from style sheet.
+     */
+    del();
+}
+
+export interface VSheet {
+    /**
+     * Re-renders style sheet according to specified CSS-like object. The `css`
+     * object is a 3-level tree structure:
+     *
+     * ```
+     * {
+     *   media-query-prelude: {
+     *     selector: {
+     *       declarations
+     *     }
+     *   }
+     * }
+     * ```
+     *
+     * Example:
+     *
+     * ```js
+     * sheet.diff({
+     *   '': {
+     *     '.my-class': {
+     *       color: 'red',
+     *     },
+     *     '.my-class:hover': {
+     *       color: 'blue',
+     *     },
+     *   },
+     *   '@media only screen and (max-width: 600px)': {
+     *     '.my-class': {
+     *       color: 'green',
+     *     },
+     *   },
+     * });
+     * ```
+     *
+     * @param css CSS-like object with media queries as top level.
+     */
+    diff(css: Css);
+}
+
+export interface VCSSOMAddon {
+    VRule: new (selector: string, mediaQuery?: string) => VRule;
+    VSheet: new () => VSheet;
+}
+
+export function addon(nano: NanoRenderer);

data/node_modules/nano-css/addon/vcssom.js

@@ -0,0 +1,97 @@
+'use strict';
+
+var removeRule = require('./vcssom/removeRule').removeRule;
+
+exports.addon = function (renderer) {
+    // VCSSOM support only browser environment.
+    if (!renderer.client) return;
+
+    if (process.env.NODE_ENV !== 'production') {
+        require('./__dev__/warnOnMissingDependencies')('cssom', renderer, ['createRule']); // cssom
+    }
+
+    var kebab = renderer.kebab;
+
+    function VRule (selector, prelude) {
+        this.rule = renderer.createRule(selector, prelude);
+        this.decl = {};
+    }
+    VRule.prototype.diff = function (newDecl) {
+        var oldDecl = this.decl;
+        var style = this.rule.style;
+        var property;
+        for (property in oldDecl)
+            if (newDecl[property] === undefined)
+                style.removeProperty(property);
+        for (property in newDecl)
+            if (newDecl[property] !== oldDecl[property])
+                style.setProperty(kebab(property), newDecl[property]);
+        this.decl = newDecl;
+    };
+    VRule.prototype.del = function () {
+        removeRule(this.rule);
+    };
+
+    function VSheet () {
+        /**
+         * {
+         *   '<at-rule-prelude>': {
+         *     '<selector>': {
+         *       color: 'red
+         *     }
+         *   }
+         * }
+         */
+        this.tree = {};
+    }
+    VSheet.prototype.diff = function (newTree) {
+        var oldTree = this.tree;
+
+        // Remove media queries not present in new tree.
+        for (var prelude in oldTree) {
+            if (newTree[prelude] === undefined) {
+                var rules = oldTree[prelude];
+                for (var selector in rules)
+                    rules[selector].del();
+            }
+        }
+
+        for (var prelude in newTree) {
+            if (oldTree[prelude] === undefined) {
+                // Whole media query is new.
+                for (var selector in newTree[prelude]) {
+                    var rule = new VRule(selector, prelude);
+                    rule.diff(newTree[prelude][selector]);
+                    newTree[prelude][selector] = rule;
+                }
+            } else {
+                // Old tree already has rules with this media query.
+                var oldRules = oldTree[prelude];
+                var newRules = newTree[prelude];
+
+                // Remove rules not present in new tree.
+                for (var selector in oldRules)
+                    if (!newRules[selector])
+                        oldRules[selector].del();
+
+                // Apply new rules.
+                for (var selector in newRules) {
+                    var rule = oldRules[selector];
+                    if (rule) {
+                        rule.diff(newRules[selector]);
+                        newRules[selector] = rule;
+                    } else {
+                        rule = new VRule(selector, prelude);
+                        rule.diff(newRules[selector]);
+                        newRules[selector] = rule;
+                    }
+                }
+            }
+        }
+
+        this.tree = newTree;
+    };
+
+    renderer.VRule = VRule;
+    renderer.VSheet = VSheet;
+};

data/node_modules/nano-css/addon/virtual.js

@@ -0,0 +1,107 @@
+'use strict';
+
+var createMemoizer = function (pfx) {
+    var offset = 10;
+    var msb = 35;
+    var power = 1;
+
+    var self = {
+        cache: {},
+        length: 0,
+
+        next: function () {
+            var vcount = self.length + offset;
+
+            if (vcount === msb) {
+                offset += (msb + 1) * 9;
+                msb = Math.pow(36, ++power) - 1;
+            }
+            self.length++;
+
+            return vcount;
+        },
+
+        get: function () {
+            var curr = self.cache;
+            var lastIndex = arguments.length - 1;
+            var lastStep = arguments[lastIndex];
+
+            for (var i = 0; i < lastIndex; i++) {
+                var step = arguments[i] || '_';
+
+                if (!curr[step]) curr[step] = {};
+                curr = curr[step];
+            }
+
+            if (!curr[lastStep]) curr[lastStep] = pfx + self.next().toString(36);
+
+            return curr[lastStep];
+        }
+    };
+
+    return self;
+};
+
+exports.addon = function (renderer) {
+    if (process.env.NODE_ENV !== 'production') {
+        require('./__dev__/warnOnMissingDependencies')('virtual', renderer, ['rule', 'putRaw']);
+    }
+
+    renderer.memo = createMemoizer(renderer.pfx);
+
+    renderer.atomic = function (selectorTemplate, rawDecl, atrule) {
+        var memo = renderer.memo;
+        var memoLength = memo.length;
+        var className = memo.get(atrule, selectorTemplate, rawDecl);
+
+        if (memoLength < memo.length) {
+            var selector = selectorTemplate.replace(/&/g, '.' + className);
+            var str = selector + '{' + rawDecl + '}';
+
+            if (atrule) {
+                str = atrule + '{' + str + '}';
+            }
+
+            renderer.putRaw(str);
+        }
+
+        return className;
+    };
+
+    renderer.virtual = function (selectorTemplate, decls, atrule) {
+        selectorTemplate = selectorTemplate || '&';
+
+        var classNames = '';
+
+        for (var prop in decls) {
+            var value = decls[prop];
+
+            if (prop.indexOf('keyframes') > -1) {
+                renderer.putAt('', value, prop);
+                continue;
+            }
+
+            if ((value instanceof Object) && !(value instanceof Array)) {
+                if (prop[0] === '@') {
+                    classNames += renderer.virtual(selectorTemplate, value, prop);
+                } else {
+                    classNames += renderer.virtual(renderer.selector(selectorTemplate, prop), value, atrule);
+                }
+            } else {
+                var rawDecl = renderer.decl(prop, value);
+                var rawDecls = rawDecl.split(';');
+
+                for (var i = 0; i < rawDecls.length; i++) {
+                    var d = rawDecls[i];
+                    if (d) classNames += ' ' + renderer.atomic(selectorTemplate, d, atrule);
+                }
+            }
+        }
+
+        return classNames;
+    };
+
+    renderer.rule = function (decls) {
+        return renderer.virtual('&', decls);
+    };
+};

data/node_modules/nano-css/addon/withStyles.js

@@ -0,0 +1,32 @@
+'use strict';
+
+exports.addon = function (renderer) {
+    if (process.env.NODE_ENV !== 'production') {
+        require('./__dev__/warnOnMissingDependencies')('withStyles', renderer, ['sheet']);
+    }
+
+    renderer.withStyles = function (map, fn, block) {
+        block = block || fn.displayName || fn.name;
+
+        var styles = renderer.sheet(map, block);
+        var Component = function (props) {
+            if (process.env.NODE_ENV !== 'production') {
+                return fn(Object.assign({}, props, {
+                    styles: styles
+                }));
+            }
+
+            props.styles = styles;
+
+            return fn(props);
+        };
+
+        if (process.env.NODE_ENV !== 'production') {
+            if (block) {
+                Component.displayName = 'withStyles(' + block + ')';
+            }
+        }
+
+        return Component;
+    };
+};

data/node_modules/nano-css/index.d.ts

@@ -0,0 +1,4 @@
+import {CreateNano} from './types/nano';
+export * from './types/nano';
+export * from './types/common';
+export const create: CreateNano;

data/node_modules/nano-css/index.js

@@ -0,0 +1,138 @@
+'use strict';
+
+var KEBAB_REGEX = /[A-Z]/g;
+
+var hash = function (str) {
+    var h = 5381, i = str.length;
+
+    while (i) h = (h * 33) ^ str.charCodeAt(--i);
+
+    return '_' + (h >>> 0).toString(36);
+};
+
+exports.create = function (config) {
+    config = config || {};
+    var assign = config.assign || Object.assign;
+    var client = typeof window === 'object';
+
+    // Check if we are really in browser environment.
+    if (process.env.NODE_ENV !== 'production') {
+        if (client) {
+            if ((typeof document !== 'object') || !document.getElementsByTagName('HTML')) {
+                console.error(
+                    'nano-css detected browser environment because of "window" global, but ' +
+                    '"document" global seems to be defective.'
+                );
+            }
+        }
+    }
+
+    var renderer = assign({
+        raw: '',
+        pfx: '_',
+        client: client,
+        assign: assign,
+        stringify: JSON.stringify,
+        kebab: function (prop) {
+            return prop.replace(KEBAB_REGEX, '-$&').toLowerCase();
+        },
+        decl: function (key, value) {
+            key = renderer.kebab(key);
+            return key + ':' + value + ';';
+        },
+        hash: function (obj) {
+            return hash(renderer.stringify(obj));
+        },
+        selector: function (parent, selector) {
+            return parent + (selector[0] === ':' ? ''  : ' ') + selector;
+        },
+        putRaw: function (rawCssRule) {
+            renderer.raw += rawCssRule;
+        }
+    }, config);
+
+    if (renderer.client) {
+        if (!renderer.sh)
+            document.head.appendChild(renderer.sh = document.createElement('style'));
+
+        if (process.env.NODE_ENV !== 'production') {
+            renderer.sh.setAttribute('data-nano-css-dev', '');
+
+            // Test style sheet used in DEV mode to test if .insetRule() would throw.
+            renderer.shTest = document.createElement('style');
+            renderer.shTest.setAttribute('data-nano-css-dev-tests', '');
+            document.head.appendChild(renderer.shTest);
+        }
+
+        renderer.putRaw = function (rawCssRule) {
+            // .insertRule() is faster than .appendChild(), that's why we use it in PROD.
+            // But CSS injected using .insertRule() is not displayed in Chrome Devtools,
+            // that's why we use .appendChild in DEV.
+            if (process.env.NODE_ENV === 'production') {
+                var sheet = renderer.sh.sheet;
+
+                // Unknown pseudo-selectors will throw, this try/catch swallows all errors.
+                try {
+                    sheet.insertRule(rawCssRule, sheet.cssRules.length);
+                // eslint-disable-next-line no-empty
+                } catch (error) {}
+            } else {
+                // Test if .insertRule() works in dev mode. Unknown pseudo-selectors will throw when
+                // .insertRule() is used, but .appendChild() will not throw.
+                try {
+                    renderer.shTest.sheet.insertRule(rawCssRule, renderer.shTest.sheet.cssRules.length);
+                } catch (error) {
+                    if (config.verbose) {
+                        console.error(error);
+                    }
+                }
+
+                // Insert pretty-printed CSS for dev mode.
+                renderer.sh.appendChild(document.createTextNode(rawCssRule));
+            }
+        };
+    }
+
+    renderer.put = function (selector, decls, atrule) {
+        var str = '';
+        var prop, value;
+        var postponed = [];
+
+        for (prop in decls) {
+            value = decls[prop];
+
+            if ((value instanceof Object) && !(value instanceof Array)) {
+                postponed.push(prop);
+            } else {
+                if ((process.env.NODE_ENV !== 'production') && !renderer.sourcemaps) {
+                    str += '    ' + renderer.decl(prop, value, selector, atrule) + '\n';
+                } else {
+                    str += renderer.decl(prop, value, selector, atrule);
+                }
+            }
+        }
+
+        if (str) {
+            if ((process.env.NODE_ENV !== 'production') && !renderer.sourcemaps) {
+                str = '\n' + selector + ' {\n' + str + '}\n';
+            } else {
+                str = selector + '{' + str + '}';
+            }
+            renderer.putRaw(atrule ? atrule + '{' + str + '}' : str);
+        }
+
+        for (var i = 0; i < postponed.length; i++) {
+            prop = postponed[i];
+
+            if (prop[0] === '@' && prop !== '@font-face') {
+                renderer.putAt(selector, decls[prop], prop);
+            } else {
+                renderer.put(renderer.selector(selector, prop), decls[prop], atrule);
+            }
+        }
+    };
+
+    renderer.putAt = renderer.put;
+
+    return renderer;
+};