isomorfeus-preact 10.5.1 → 10.5.2

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

@@ -0,0 +1,15 @@
+'use strict';
+
+var rtl = require('rtl-css-js').default;
+
+exports.addon = function (renderer) {
+    if (process.env.NODE_ENV !== 'production') {
+        require('./__dev__/warnOnMissingDependencies')('rtl', renderer, ['put']);
+    }
+
+    var put = renderer.put;
+
+    renderer.put = function (selector, css) {
+        return put(selector, rtl(css));
+    };
+};

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

@@ -0,0 +1,26 @@
+import {CssLikeObject} from '../types/common';
+import {NanoRenderer} from '../types/nano';
+
+export interface RuleAddon {
+    /**
+     * You need to install `rule` addon to add this method.
+     *
+     * ```js
+     * import {create} from 'nano-css';
+     * import {addon as addonRule} from 'nano-css/addon/rule';
+     *
+     * const nano = create();
+     * addonRule(nano);
+     *
+     * const className = nano.rule({
+     *   color: 'red',
+     * });
+     * ```
+     *
+     * @param css [CSS-like object](https://github.com/streamich/nano-css/blob/master/docs/put.md#css-like-object).
+     * @param block Optional semantic name of this rule, must be unique.
+     */
+    rule: (css: CssLikeObject, block?: string) => string;
+}
+
+export function addon(nano: NanoRenderer);

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

@@ -0,0 +1,39 @@
+'use strict';
+
+exports.addon = function (renderer) {
+    if (process.env.NODE_ENV !== 'production') {
+        require('./__dev__/warnOnMissingDependencies')('rule', renderer, ['put']);
+    }
+
+    var blocks;
+
+    if (process.env.NODE_ENV !== 'production') {
+        blocks = {};
+    }
+
+    renderer.rule = function (css, block) {
+        // Warn user if CSS selectors clash.
+        if (process.env.NODE_ENV !== 'production') {
+            if (block) {
+                if (typeof block !== 'string') {
+                    throw new TypeError(
+                        'nano-css block name must be a string. ' +
+                        'For example, use nano.rule({color: "red", "RedText").'
+                    );
+                }
+
+                if (blocks[block]) {
+                    console.error('Block name "' + block + '" used more than once.');
+                }
+
+                blocks[block] = 1;
+            }
+        }
+
+        block = block || renderer.hash(css);
+        block = renderer.pfx + block;
+        renderer.put('.' + block, css);
+
+        return ' ' + block;
+    };
+};

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

@@ -0,0 +1,22 @@
+import {CssLikeObject} from '../types/common';
+import {NanoRenderer} from '../types/nano';
+
+export interface SheetAddon {
+    /**
+     * Creates a collection of CSS rules.
+     *
+     * ```js
+     * const classes = sheet({
+     *     wrapper: {
+     *         border: '1px solid red',
+     *     },
+     *     button: {
+     *         color: 'red',
+     *     },
+     * });
+     * ```
+     */
+    sheet: (cssMap: {[s: string]: CssLikeObject}, block?: string) => {[s: string]: string};
+}
+
+export function addon(nano: NanoRenderer);

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

@@ -0,0 +1,45 @@
+'use strict';
+
+exports.addon = function (renderer) {
+    if (process.env.NODE_ENV !== 'production') {
+        require('./__dev__/warnOnMissingDependencies')('sheet', renderer, ['rule']);
+    }
+
+    renderer.sheet = function (map, block) {
+        var result = {};
+
+        if (!block) {
+            block = renderer.hash(map);
+        }
+
+        var onElementModifier = function (elementModifier) {
+            var styles = map[elementModifier];
+
+            if ((process.env.NODE_ENV !== 'production') && renderer.sourcemaps) {
+                // In dev mode emit CSS immediately to generate sourcemaps.
+                result[elementModifier] = renderer.rule(styles, block + '-' + elementModifier);
+            } else {
+                Object.defineProperty(result, elementModifier, {
+                    configurable: true,
+                    enumerable: true,
+                    get: function () {
+                        var classNames = renderer.rule(styles, block + '-' + elementModifier);
+
+                        Object.defineProperty(result, elementModifier, {
+                            value: classNames,
+                            enumerable: true
+                        });
+
+                        return classNames;
+                    },
+                });
+            }
+        };
+
+        for (var elementModifier in map) {
+            onElementModifier(elementModifier);
+        }
+
+        return result;
+    };
+};

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

@@ -0,0 +1,141 @@
+/* eslint-disable no-invalid-this */
+'use strict';
+
+var atoms = require('./atoms').atoms;
+
+exports.addon = function (renderer, rules) {
+    rules = rules || {};
+
+    var defaultRules = renderer.assign({}, atoms, {
+        s: function (prop, value) {
+            if (prop instanceof Object) {
+                for (var name in prop) {
+                    defaultRules.s.call(this, name, prop[name]);
+                }
+            } else {
+                this[prop] = (value instanceof Object) ? (value.obj || value) : value;
+            }
+        },
+
+        hover: function (value) {
+            defaultRules.s.call(this, ':hover', value);
+        },
+
+        focus: function (value) {
+            defaultRules.s.call(this, ':focus', value);
+        },
+
+        bgWhite: function () {
+            this.backgroundColor = '#fff';
+        },
+
+        bgBlack: function () {
+            this.backgroundColor = '#000';
+        },
+
+        rel: function () {
+            this.position = 'relative';
+        },
+
+        abs: function () {
+            this.position = 'absolute';
+        },
+
+        pointer: function () {
+            this.cursor = 'pointer';
+        },
+
+        inlineBlock: function () {
+            this.display = 'inline-block';
+        },
+
+        bold: function () {
+            this.fontWeight = 'bold';
+        },
+
+        b: function () {
+            this.fontWeight = 'bold';
+        },
+
+        italic: function () {
+            this.fontStyle = 'italic';
+        },
+
+        i: function () {
+            this.fontStyle = 'italic';
+        },
+
+        underline: function () {
+            this.textDecoration = 'underline';
+        },
+
+        u: function () {
+            this.textDecoration = 'underline';
+        },
+    });
+
+    rules = renderer.assign(defaultRules, rules);
+
+    var snake = {};
+
+    var start = function () {
+        var instance = Object.create(snake);
+
+        instance.obj = {};
+        instance.toString = function () {
+            if (process.env.NODE_ENV !== 'production') {
+                require('./__dev__/warnOnMissingDependencies')('snake', renderer, ['cache']);
+            }
+
+            return renderer.cache(instance.obj);
+        };
+        instance.valueOf = instance.toString;
+
+        return instance;
+    };
+
+    var checkStart = function (name, fn) {
+        return function () {
+            if (!this.obj) {
+                var instance = start();
+
+                if (typeof instance[name] === 'function') {
+                    return instance[name].apply(instance, arguments);
+                }
+
+                return instance[name];
+            }
+
+            return fn.apply(this, arguments);
+        };
+    };
+
+    var onRule = function (name) {
+        var rule = rules[name];
+
+        if (typeof rule === 'function') {
+            if (!rule.length) {
+                Object.defineProperty(snake, name, {
+                    get: checkStart(name, function () {
+                        rule.call(this.obj);
+                        return this;
+                    })
+                });
+            } else {
+                snake[name] = checkStart(name, function () {
+                    rule.apply(this.obj, arguments);
+                    return this;
+                });
+            }
+        } else {
+            snake[name] = checkStart(name, function (value) {
+                this.obj['' + rule] = value;
+                return this;
+            });
+        }
+    };
+
+    for (var name in rules) onRule(name);
+
+    renderer.s = snake;
+};

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

@@ -0,0 +1,96 @@
+'use strict';
+
+var StackTrace = require('stacktrace-js');
+var SourcemapCodec = require('sourcemap-codec');
+
+function findStackframe (frames) {
+    for (var i = 4; i < frames.length; i++) {
+        if (!frames[i].fileName.match(/addon\/[^.]+\.js/)) {
+            return frames[i];
+        }
+    }
+}
+
+exports.addon = function (renderer) {
+    if (process.env.NODE_ENV === 'production') {
+        // eslint-disable-next-line no-console
+        console.log(
+            'nano-css sourcemaps addon should be installed only in development mode. ' +
+            'Use (process.env.NODE !== "production") to check if you are in development mode.'
+        );
+
+        return;
+    }
+
+    var queue = [];
+    var timeout = null;
+    var sourceCache = {};
+
+    function flush () {
+        timeout = null;
+
+        var sources = [];
+        var segments = [];
+        var rules = [];
+
+        for (var i = 0; i < queue.length; i++) {
+            var item = queue[i];
+
+            rules.push(item.rule);
+            segments.push([[0, sources.length, item.lineNumber - 1, 0]]);
+            sources.push(item.fileName);
+        }
+
+        queue = [];
+
+        var mappings = SourcemapCodec.encode(segments);
+        var map = {
+            version: 3,
+            sources: sources,
+            mappings: mappings,
+            sourcesContent: sources.map(function (source) {
+                return sourceCache[source];
+            }),
+        };
+
+        var json = JSON.stringify(map);
+        var base64 = window.btoa(json);
+        var css = rules.join('\n') + '\n/*# sourceMappingURL=data:application/json;charset=utf-8;base64,' + base64 + ' */';
+        var style = document.createElement('style');
+
+        style.setAttribute('data-nano-css-sourcemaps', '');
+        style.appendChild(document.createTextNode(css));
+        document.head.appendChild(style);
+    }
+
+    function enqueue (rawCss) {
+        StackTrace.get({sourceCache: sourceCache})
+            .then(function (stackframes) {
+                var frame = findStackframe(stackframes);
+
+                if (!frame) {
+                    return;
+                }
+
+                queue.push({
+                    rule: rawCss,
+                    fileName: frame.fileName,
+                    lineNumber: frame.lineNumber,
+                });
+
+                if (!timeout) {
+                    timeout = setTimeout(flush, 100);
+                }
+            // eslint-disable-next-line no-console
+            }, console.log);
+    }
+
+    var putRaw = renderer.putRaw;
+
+    renderer.putRaw = function (rawCSS) {
+        enqueue(rawCSS);
+        putRaw.apply(null, arguments);
+    };
+
+    renderer.sourcemaps = true;
+};

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

@@ -0,0 +1,23 @@
+'use strict';
+
+exports.addon = function (renderer) {
+    if (process.env.NODE_ENV !== 'production') {
+        require('./__dev__/warnOnMissingDependencies')('spread', renderer, ['put']);
+    }
+
+    renderer.spread = function (css, block) {
+        block = block || renderer.hash(css);
+        block = renderer.pfx + block;
+        renderer.put('.' + block + ',[data-' + block + ']', css);
+
+        var spread = {
+            toString: function () {
+                return ' ' + block;
+            }
+        };
+
+        spread['data-' + block] = '';
+
+        return spread;
+    };
+};

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

@@ -0,0 +1,7 @@
+'use strict';
+
+var stringify = require('fastest-stable-stringify');
+
+exports.addon = function (renderer) {
+    renderer.stringify = stringify;
+};

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

@@ -0,0 +1,33 @@
+'use strict';
+
+exports.addon = function (renderer) {
+    if (process.env.NODE_ENV !== 'production') {
+        require('./__dev__/warnOnMissingDependencies')('style', renderer, ['jsx']);
+    }
+
+    renderer.style = function (fn, styles, dynamicTemplate, block) {
+        var jsxComponent = renderer.jsx(fn, styles, block);
+
+        var Component = function(props) {
+            var copy = props;
+
+            if (process.env.NODE_ENV !== 'production') {
+                copy = Object.assign({}, props);
+            }
+
+            if (dynamicTemplate) {
+                copy.css = dynamicTemplate(props);
+            }
+
+            return jsxComponent(copy);
+        };
+
+        if (process.env.NODE_ENV !== 'production') {
+            if (block || (typeof fn === 'function')) {
+                Component.displayName = 'style(' + (block || fn.displayName || fn.name) + ')';
+            }
+        }
+
+        return Component;
+    };
+};