lasso/dist-compat/index.js

Lasso.js is a build tool and runtime library for building and bundling all of the resources needed by a web application

let lassoPage = (() => {
    var _ref = _asyncToGenerator(function* (pageConfig) {
        ok(pageConfig, '"pageConfig" is required');
        ok(typeof pageConfig === 'object', '"pageConfig" should be an object');

        var dependencies = pageConfig.dependencies;
        var packagePath = pageConfig.packagePath;

        ok(dependencies || packagePath, '"page.dependencies" or "page.packagePath" is required');
        if (dependencies) {
            ok(typeof dependencies === 'string' || Array.isArray(dependencies), '"dependencies" should be an Array or a String');
        }

        if (typeof dependencies === 'string') {
            packagePath = nodePath.resolve(process.cwd(), dependencies);
            dependencies = null;
        } else if (typeof packagePath === 'string') {
            packagePath = nodePath.resolve(process.cwd(), packagePath);
        }

        return getDefaultLasso().lassoPage(pageConfig);
    });

    return function lassoPage(_x) {
        return _ref.apply(this, arguments);
    };
})();

let lassoResource = (() => {
    var _ref2 = _asyncToGenerator(function* (path, context) {
        return getDefaultLasso().lassoResource(path, context);
    });

    return function lassoResource(_x2, _x3) {
        return _ref2.apply(this, arguments);
    };
})();

function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }

require('raptor-logging');

const nodePath = require('path');
const configLoader = require('./config-loader');
const flags = require('./flags');
const transforms = require('./transforms');
const ok = require('assert').ok;
const fs = require('fs');
const raptorCache = require('raptor-cache');
const extend = require('raptor-util/extend');
const getClientPath = require('lasso-modules-client/transport').getClientPath;
const stripJsonComments = require('strip-json-comments');

if (!getClientPath) {
    throw new Error('getClientPath is not defined');
}

var configDefaults = {
    outputDir: 'static',
    urlPrefix: '/static',
    includeSlotNames: false,
    fingerprintsEnabled: true,
    resolveCssUrls: true,
    bundlingEnabled: true,
    minify: false
};

exports.defaultConfig = {};
exports.defaultConfigBaseDir = process.cwd();
exports.defaultConfigFilename = null;

function create(config, baseDir, filename) {
    if (!config) {
        config = exports.defaultConfig;
    } else if (typeof config === 'string') {
        filename = config;
        filename = nodePath.resolve(process.cwd(), filename);

        baseDir = nodePath.dirname(filename);
        var json = fs.readFileSync(filename, { encoding: 'utf8' });
        config = JSON.parse(stripJsonComments(json));
    }

    if (!baseDir) {
        baseDir = config.baseDir || process.cwd();
    }

    if (!config.__Config) {
        config = configLoader.load(config, baseDir, filename, configDefaults);
    }

    var Lasso = require('./Lasso');
    var theLasso = new Lasso(config);
    return theLasso;
}

var defaultLasso = null;
var isConfigured = false;

function getDefaultLasso() {
    if (!defaultLasso) {
        // Fixes #82 - Make lasso a singleton. When resolving the default
        //             lasso use the global lasso unless this lasso
        //             was explicitly configured.
        if (!isConfigured && global.GLOBAL_LASSO) {
            defaultLasso = global.GLOBAL_LASSO.getDefaultLasso();
            return defaultLasso;
        }

        defaultLasso = create(exports.defaultConfig, exports.defaultConfigBaseDir, exports.defaultConfigFilename);
    }

    return defaultLasso;
}

function setDevelopmentMode() {
    extend(configDefaults, {
        fingerprintsEnabled: false,
        bundlingEnabled: false,
        minify: false
    });
}

var NODE_ENV = process.env.NODE_ENV && process.env.NODE_ENV.toLowerCase();

if (NODE_ENV === 'development' || NODE_ENV === 'dev') {
    setDevelopmentMode();
}

function configure(config, baseDir, filename) {
    // Fixes #82 - Make lasso a singleton. The first lasso that is
    //             explicitly configured will become the default
    //             global instance.
    isConfigured = true;

    if (!global.GLOBAL_LASSO) {
        global.GLOBAL_LASSO = exports;
    }

    // Clear out the default lasso instance since that it will
    // be recreated with the new config.
    defaultLasso = null;

    exports.defaultConfig = config = config || {};
    exports.defaultConfigBaseDir = baseDir;
    exports.defaultConfigFilename = filename;
}

function clearCaches() {
    raptorCache.freeAll();
    require('./caching-fs').clearCaches();
}

exports.getDefaultLasso = getDefaultLasso;
exports.lassoPage = lassoPage;
exports.lassoResource = lassoResource;
exports.create = create;
exports.configure = configure;
exports.setDevelopmentMode = setDevelopmentMode;

exports.createFlagSet = flags.createFlagSet;
exports.isFlagSet = flags.isFlagSet;

exports.transforms = transforms;
exports.writers = require('./writers');

exports.flushAllCaches = raptorCache.flushAll;

exports.handleWatchedFileChanged = function (path) {
    console.log('[lasso] File modified: ' + path);
    clearCaches();
};

exports.clearCaches = clearCaches;
exports.getClientPath = getClientPath;

Object.defineProperty(exports, 'defaultLasso', {
    get: getDefaultLasso,
    enumerable: true,
    configurable: false
});

exports.toString = function () {
    return '[lasso@' + __filename + ']';
};

require('../browser-refresh').enable();