isomorfeus-preact 10.5.0 → 10.5.4

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

@@ -0,0 +1,78 @@
+'use strict';
+
+var UNITLESS_NUMBER_PROPS = [
+    'animation-iteration-count',
+    'border-image-outset',
+    'border-image-slice',
+    'border-image-width',
+    'box-flex',
+    'box-flex-group',
+    'box-ordinal-group',
+    'column-count',
+    'columns',
+    'flex',
+    'flex-grow',
+    'flex-positive',
+    'flex-shrink',
+    'flex-negative',
+    'flex-order',
+    'grid-row',
+    'grid-row-end',
+    'grid-row-span',
+    'grid-row-start',
+    'grid-column',
+    'grid-column-end',
+    'grid-column-span',
+    'grid-column-start',
+    'font-weight',
+    'line-clamp',
+    'line-height',
+    'opacity',
+    'order',
+    'orphans',
+    'tabSize',
+    'widows',
+    'z-index',
+    'zoom',
+
+    // SVG-related properties
+    'fill-opacity',
+    'flood-opacity',
+    'stop-opacity',
+    'stroke-dasharray',
+    'stroke-dashoffset',
+    'stroke-miterlimit',
+    'stroke-opacity',
+    'stroke-width',
+];
+
+var unitlessCssProperties = {};
+
+for (var i = 0; i < UNITLESS_NUMBER_PROPS.length; i++) {
+    var prop = UNITLESS_NUMBER_PROPS[i];
+
+    unitlessCssProperties[prop] = 1;
+    unitlessCssProperties['-webkit-' + prop] = 1;
+    unitlessCssProperties['-ms-' + prop] = 1;
+    unitlessCssProperties['-moz-' + prop] = 1;
+    unitlessCssProperties['-o-' + prop] = 1;
+}
+
+exports.addon = function (renderer) {
+    var decl = renderer.decl;
+
+    renderer.decl = function (prop, value) {
+        var str = decl(prop, value);
+
+        if (typeof value === 'number') {
+            var pos = str.indexOf(':');
+            var propKebab = str.substr(0, pos);
+
+            if (!unitlessCssProperties[propKebab]) {
+                return decl(prop, value + 'px');
+            }
+        }
+
+        return str;
+    };
+};

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

@@ -0,0 +1,89 @@
+import {NanoRenderer} from '../types/nano';
+
+export interface Units {
+    /**
+     * Adds `px` postfix.
+     */
+    px: (val: number) => string;
+
+    /**
+     * Adds `cm` postfix.
+     */
+    cm: (val: number) => string;
+
+    /**
+     * Adds `pt` postfix.
+     */
+    pt: (val: number) => string;
+
+    /**
+     * Adds `pc` postfix.
+     */
+    pc: (val: number) => string;
+
+    /**
+     * Adds `em` postfix.
+     */
+    em: (val: number) => string;
+
+    /**
+     * Adds `ex` postfix.
+     */
+    ex: (val: number) => string;
+
+    /**
+     * Adds `ch` postfix.
+     */
+    ch: (val: number) => string;
+
+    /**
+     * Adds `rem` postfix.
+     */
+    rem: (val: number) => string;
+
+    /**
+     * Adds `vw` postfix.
+     */
+    vw: (val: number) => string;
+
+    /**
+     * Adds `vh` postfix.
+     */
+    vh: (val: number) => string;
+
+    /**
+     * Adds `deg` postfix.
+     */
+    deg: (val: number) => string;
+
+    /**
+     * Adds `vmin` postfix.
+     */
+    vmin: (val: number) => string;
+
+    /**
+     * Adds `vmax` postfix.
+     */
+    vmax: (val: number) => string;
+
+    /**
+     * Adds `in` postfix.
+     */
+    inch: (val: number) => string;
+
+    /**
+     * Adds `in` postfix.
+     */
+    in: (val: number) => string;
+
+    /**
+     * Adds `%` postfix.
+     */
+    pct: (val: number) => string;
+}
+
+export interface UnitsAddon extends Units {
+    units: Units;
+}
+
+export function addon(nano: NanoRenderer);

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

@@ -0,0 +1,27 @@
+'use strict';
+
+var units = {};
+var unitList = 'px,cm,mm,in,pt,pc,em,ex,ch,rem,vw,vh,deg,vmin,vmax'.split(',');
+
+function f (unit, val) {
+    return val + unit;
+}
+
+for (var i = 0; i < unitList.length; i++) {
+    var unit = unitList[i];
+
+    units[unit] = f.bind(null, unit);
+}
+
+units.inch = function (val) {
+    return val + 'in';
+};
+
+units.pct = function (val) {
+    return val + '%';
+};
+
+exports.addon = function (renderer) {
+    renderer.assign(renderer, units);
+    renderer.units = units;
+};

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

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

data/node_modules/nano-css/addon/util/cloneElement.js

@@ -0,0 +1,11 @@
+'use strict';
+
+module.exports = function (renderer, element, props) {
+    var newProps = renderer.assign({}, element.props, props);
+
+    if (element.ref) {
+        newProps.ref = element.ref;
+    }
+
+    return renderer.h(element.type, newProps);
+};

data/node_modules/nano-css/addon/util/transformComponentDynamic.js

@@ -0,0 +1,50 @@
+'use strict';
+
+module.exports = function (renderer, Comp, dynamicTemplate) {
+    if (process.env.NODE_ENV !== 'production') {
+        if (typeof dynamicTemplate !== 'function') {
+            var what;
+
+            try {
+                what = JSON.stringify(dynamicTemplate);
+            } catch (error) {
+                what = String(dynamicTemplate);
+            }
+
+            throw new TypeError('Dynamic CSS template must always be a function, ' + 'received: ' + what);
+        }
+    }
+
+    var prototype = Comp.prototype;
+    var render_ = prototype.render;
+
+    prototype.render = function () {
+        var element = render_.apply(this, arguments);
+        var props = element.props;
+        var dynamicClassName = '';
+
+        if (dynamicTemplate) {
+            var dynamicStyles = dynamicTemplate(this.props);
+
+            if (dynamicStyles) {
+                dynamicClassName = renderer.cache(dynamicStyles);
+            }
+        }
+
+        if (!dynamicClassName) {
+            return element;
+        }
+
+        var className = (props.className || '') + dynamicClassName;
+
+        if (process.env.NODE_ENV !== 'production') {
+            return require('react').cloneElement(element, Object.assign({}, props, {
+                className: className
+            }), props.children);
+        }
+
+        props.className = className;
+
+        return element;
+    };
+};

data/node_modules/nano-css/addon/util/transformComponentStatic.js

@@ -0,0 +1,26 @@
+'use strict';
+
+module.exports = function (renderer, prototype, styles, block) {
+    var render_ = prototype.render;
+    var className = '';
+
+    prototype.render = function () {
+        var element = render_.call(this);
+
+        if (element) {
+            if (!className) {
+                className = renderer.rule(styles, block);
+            }
+
+            if (process.env.NODE_ENV === 'production') {
+                element.props.className = (element.props.className || '') + className;
+            } else {
+                element = require('react').cloneElement(element, {
+                    className: (element.props.className || '') + className,
+                });
+            }
+        }
+
+        return element;
+    };
+};

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

@@ -0,0 +1,82 @@
+'use strict';
+
+var csstree = require('css-tree');
+var syntax = csstree.lexer;
+
+function validate(css, filename) {
+    var errors = [];
+    var ast = csstree.parse(css, {
+        filename: filename,
+        positions: true,
+        onParseError: function(error) {
+            errors.push(error);
+        }
+    });
+
+    csstree.walk(ast, {
+        visit: 'Declaration',
+        enter: function(node) {
+            var match = syntax.matchDeclaration(node);
+            var error = match.error;
+
+            if (error) {
+                var message = error.rawMessage || error.message || error;
+
+                // ignore errors except those which make sense
+                if (error.name !== 'SyntaxMatchError' &&
+                    error.name !== 'SyntaxReferenceError') {
+                    return;
+                }
+
+                if (message === 'Mismatch') {
+                    message = 'Invalid value for `' + node.property + '`';
+                } else if (message === 'Uncomplete match') {
+                    message = 'The rest part of value can\'t be matched to `' + node.property + '` syntax';
+                }
+
+                errors.push({
+                    name: error.name,
+                    node: node,
+                    loc: error.loc || node.loc,
+                    line: error.line || node.loc && node.loc.start && node.loc.start.line,
+                    column: error.column || node.loc && node.loc.start && node.loc.start.column,
+                    property: node.property,
+                    message: message,
+                    error: error
+                });
+            }
+        }
+    });
+
+    return errors;
+}
+
+exports.addon = function (renderer) {
+    if (process.env.NODE_ENV !== 'production') {
+        require('./__dev__/warnOnMissingDependencies')('validate', renderer, ['putRaw']);
+    }
+
+    if (process.env.NODE_ENV === 'production') {
+        console.warn(
+            'You are using nano-css "validate" in production. ' +
+            'This addon is meant to be used only in development.'
+        );
+    }
+
+    var putRaw = renderer.putRaw;
+
+    renderer.putRaw = function (rawCssRule) {
+        var errors = validate(rawCssRule);
+
+        if (errors && errors.length) {
+            errors.forEach(function (error) {
+                console.error('nano-css error, ' + error.name + ': ' + error.message);
+                // eslint-disable-next-line
+                console.log(error);
+                console.error(rawCssRule);
+            });
+        }
+
+        return putRaw.apply(renderer, arguments);
+    };
+};

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

@@ -0,0 +1,159 @@
+/* eslint-disable */
+'use strict';
+
+var cssToTree = require('../cssToTree').cssToTree;
+
+describe('cssToTree', function () {
+    test('exist', function () {
+        expect(cssToTree).toBeInstanceOf(Function);
+    });
+
+    test('simple object', () => {
+        var tree = {};
+        cssToTree(tree, {color: 'red'}, '&', '');
+
+        expect(tree).toEqual({
+            '': {
+                '&': {
+                    color: 'red'
+                }
+            }
+        });
+    });
+
+    test('multiple properties', () => {
+        var tree = {};
+        var css = {
+            color: 'red',
+            border: '1px solid tomato',
+            textDecoration: 'underline,'
+        };
+        cssToTree(tree, css, '&', '');
+
+        expect(tree).toEqual({ '':
+        { '&':
+           { color: 'red',
+             border: '1px solid tomato',
+             textDecoration: 'underline,' } } });
+    });
+
+    test('nested selector', () => {
+        var tree = {};
+        var css = {
+            color: 'red',
+            svg: {
+                fill: 'green',
+            }
+        };
+        cssToTree(tree, css, 'X', '');
+
+        expect(tree).toEqual({
+            '': {
+                'X svg': {
+                    fill: 'green'
+                },
+                X: {
+                    color: 'red'
+                }
+            }
+        });
+    });
+
+    test('nesting with single & pseudo selector', () => {
+        var tree = {};
+        var css = {
+            svg: {
+                fill: 'red',
+            },
+            '&:hover': {
+                fill: 'green',
+            }
+        };
+        cssToTree(tree, css, 'X', '');
+
+        expect(tree).toEqual({"": {"X svg": {"fill": "red"}, "X:hover": {"fill": "green"}}});
+    });
+
+    test('more complicated nesting', () => {
+        var tree = {};
+        var css = {
+            border: '1px solid red',
+            fontFamily: 'monospace',
+            '&:hover': {
+                color: 'red',
+            },
+            '.global_class &': {
+                textDecoration: 'underline',
+            },
+            '& svg': {
+                fill: 'red',
+            },
+            '&:hover svg': {
+                fill: 'green',
+            }
+        };
+        cssToTree(tree, css, 'X', '');
+
+        expect(tree).toEqual({ '':
+        { X: { border: '1px solid red', fontFamily: 'monospace' },
+          'X:hover': { color: 'red' },
+          '.global_class X': { textDecoration: 'underline' },
+          'X svg': { fill: 'red' },
+          'X:hover svg': { fill: 'green' } } });
+    });
+
+    test('interpolates multiple ampersands', () => {
+        var tree = {};
+        var css = {
+            '&:hover,&:active': {
+                color: 'red',
+            },
+        };
+        cssToTree(tree, css, 'X', '');
+
+        expect(tree).toEqual({ '': { 'X:hover,X:active': { color: 'red' } } });
+    });
+
+    test('interpolates multiple ampersands wither further nesting', () => {
+        var tree = {};
+        var css = {
+            '&:hover,&:active': {
+                svg: {
+                    fill: 'red',
+                }
+            },
+        };
+        cssToTree(tree, css, 'X', '');
+
+        expect(tree).toEqual({ '': { 'X:hover svg,X:active svg': { fill: 'red' } } });
+    });
+
+    test('supports media query', () => {
+        var tree = {};
+        var css = {
+            '@media screen': {
+                color: 'red',
+            }
+        };
+        cssToTree(tree, css, 'X', '');
+
+        expect(tree).toEqual({ '@media screen': { X: { color: 'red' } } });
+    });
+
+    test('media query with other values', () => {
+        var tree = {};
+        var css = {
+            color: 'green',
+            '@media screen': {
+                color: 'red',
+                '&:hover': {
+                    color: 'blue',
+                }
+            }
+        };
+        cssToTree(tree, css, 'X', '');
+
+        expect(tree).toEqual({ '': { X: { color: 'green' } },
+        '@media screen': { X: { color: 'red' }, 'X:hover': { color: 'blue' } } });
+    });
+});