@extjs/sencha-cmd-linux-32/dist/js/node_modules/fashion/src/Runtime.js

Productivity and performance optimization tool for building applications with Sencha Ext JS and Sencha Touch.

"use strict";

var Fashion = require('./export/Base.js'),
    Base = Fashion.Base;
var BaseRuntime = require('./export/Runtime.js');

var Type = require('./export/type/Type.js');
var List = require('./export/type/List.js');
var Bool = require('./export/type/Bool.js');

var Literal = require('./export/type/Literal.js'),
    Null = Literal.Null;

var Declaration = require('./type/Declaration.js');
var Ruleset = require('./type/Ruleset.js');
var CSS = require('./CSS.js');
var TypeVisitor = require('./type/TypeVisitor.js');
var Types = require('./type/Types.js');
var SelectorList = require('./type/selectors/SelectorList.js');

var ColorFunctions = require('./functions/Color.js');
var Gradients = require('./functions/Gradients.js');
var HSL = require('./functions/HSL.js');
var Introspection = require('./functions/Introspection.js');
var ListFunctions = require('./functions/List.js');
var Misc = require('./functions/Misc.js');
var Numeric = require('./functions/Numeric.js');
var Opacity = require('./functions/Opacity.js');
var RGB = require('./functions/RGB.js');
var Selectors = require('./functions/Selectors.js');
var Text = require('./functions/Text.js');
var Util = require('./functions/Util.js');
var NameRegistrations = require('./processors/NameRegistrations.js');
var DataInline = require('./processors/DataInline.js');
var CssVariables = require('./processors/CssVariables.js');

class Runtime extends BaseRuntime {
    constructor(config) {
        super(config);
        var me = this;

        me.deferredContent = [];
        
        ColorFunctions.init(me);
        Gradients.init(me);
        HSL.init(me);
        Introspection.init(me);
        ListFunctions.init(me);
        Misc.init(me);
        Numeric.init(me);
        Opacity.init(me);
        RGB.init(me);
        Selectors.init(me);
        Text.init(me);
        Util.init(me);
        NameRegistrations.init(me);
        DataInline.init(me);
        CssVariables.init(me);
    }

    ruleset(selectors, sourceInfo, docs, blockDocs, hasBlock) {
        var ruleset = this.openRuleset(selectors);
        ruleset.sourceInfo = sourceInfo;
        ruleset.docs = docs;
        ruleset.blockDocs = blockDocs;
        ruleset.hasBlock = hasBlock;
        return ruleset;
    }

    rulesetDone() {
        var current = this.closeRuleset();
        this.printRuleset(current);
        return current;
    }

    namespacedRuleset(ns) {
        var ruleset = this.openRuleset(new SelectorList([]));

        ruleset.isNamespaced = true;
        ruleset.parent.removeChildRuleset(ruleset);
        ruleset.parent = null;
        ns = ns.toString();

        this.rulesets.pop();
        this.declare(ns, ruleset);
        this.rulesets.push(ruleset);
    }

    declare(property, value, important, sourceInfo, docs) {
        var isNull = false;

        if (value.$isFashionList && value.items.length === 1) {
            value = value.items[0];
        }

        if (typeof value === 'undefined' || value === null || value === Null) {
            isNull = true;
        }

        //if (value && value.$isFashionLiteral && value.value === 'null') {
        //    isNull = true;
        //}

        if (!isNull || important) {
            this.getCurrentRuleset().addDeclaration(new Declaration({
                property: property,
                value: value,
                important: important,
                sourceInfo: sourceInfo,
                docs: docs
            }));
        }
    }

    extendSelector(selector) {
        var current = this.getCurrentRuleset();
        if (!current.extend) {
            this.extenders.push(current);
            current.extend = [];
        }
        current.extend.push(selector);
    }

    openRuleset(selectors) {
        var current = this.getCurrentRuleset(),
            ruleset = new Ruleset({
                selectors: selectors,
                parent: current
            });
        if (current) {
            current.addChildRuleset(ruleset);
        }
        this.rulesets.push(ruleset);
        return ruleset;
    }

    closeRuleset() {
        return this.rulesets.pop();
    }

    getCurrentRuleset() {
        var rulesets = this.rulesets;
        return rulesets[rulesets.length - 1];
    }

    getCurrentRulesets() {
        return this.rulesets;
    }

    addDirectiveRuleset(name, value) {
        this.printRuleset(new Ruleset({
            isAtDirective: true,
            atDirectiveName: name,
            atDirectiveValue: value
        }));
    }

    printRuleset(ruleset) {
        if (!ruleset.parent && !ruleset.isNamespaced) {
            this.css.addRuleset(ruleset);
        }
    }

    /**************** overrides ****************/
    reset() {
        super.reset();
        this.css = new CSS({context: this.context});
        this.css.processors = this.processors.slice();
        this.rulesets = [];
        this.extenders = [];
    }

    registerProcessor(proc) {
        this.processors.push(new TypeVisitor(proc));
    }

    compile(code) {
        var me = this,
            theFn = super.compile(code);

        this.fn = function(rt, overrides, dyn) {
            var runtime = rt || me;
            theFn(runtime, overrides, dyn);
            runtime.runDeferred();
            runtime.css.extenders = runtime.extenders;
            return runtime.css;
        };
        return this.fn;
    }

    defer (name, fn) {
        this.deferredContent.push({
            name: name,
            fn: fn
        });
    }
    
    runDeferred(name) {
        var deferred = this.deferredContent,
            newDeferred = [],
            d;
        while(deferred.length) {
            d = deferred.shift();
            if (!name || d.name === name) {
                d.fn();
            }
            else {
                newDeferred.push(d);
            }
        }
        this.deferredContent = newDeferred;
    }
    
}

Fashion.apply(Runtime, {
    uniqueScopesForGlobalRulesets: true,
    uniqueScopesForAllRulesets: true,
    allowSetScopedVariables: true,
    allowMultipleImports: true,
    allowNullDefaults: true,
    allowEmptyRulesets: false,
    fullExtendWeave: false,
    compactSuperSelectors: false
});

Fashion.apply(Runtime.prototype, {
    extenders: null,
    mixins: null,
    rulesets: null,
    css: null,
    types: Types,

    mediaTest: /@media/,
    keyframesTest: /@.*?keyframes/
});

module.exports = Runtime;