TypeScript gulp4.src函數代碼示例

export default function Revision() {
    let settings = helper.getSettings();
    if (!helper.isRelease()) return Promise.resolve();
    if (settings.revisionExclude === "*") {
        return gulp.src(helper.getTempFolder() + '/**')
            .pipe(gulp.dest(helper.getDistFolder()));
    }
    let excludedFiles = _.union(
        ['favicon.ico', 'index.html'],
        _.map(settings.revisionExclude, (rule: any) => rule.regexp ? new RegExp(rule.pattern) : rule.pattern));
    return gulp.src(helper.getTempFolder() + '/**')
        .pipe(RevAll.revision({
            dontRenameFile: excludedFiles,
            dontUpdateReference: excludedFiles,
            dontSearchFile: [/.*\.pdf/]
        }))
        .pipe(gulp.dest(helper.getDistFolder()));
}

export default function Scaffolding() {
    let name = helper.getCurrentTarget();
    if (!name) {
        return Promise.reject(new Error("Missing required project name"));
    }
    let projectPath = path.resolve(__dirname, "../../scaffolding", helper.getProjectType());
    return gulp.src(projectPath + '/**/*')
        .pipe(replace("$$NAME", name))
        .pipe(gulp.dest(`./${name}`));
}

export default function Typescript() {
    let settings = helper.getSettings(),
        tsProject = ts.createProject("tsconfig.json", {typescript: require(settings.typescriptPath)});

    return gulp.src(settings.scripts)
        .pipe(tsProject())
        .on("error", function (error) {
            if (!helper.isWatching())
                process.exit(1);
        })
        .pipe(gulp.dest(settings.distribution));
}

export default function Test() {
    return gulp.src(helper.getSettings().test, {read: false})
        .pipe(mocha({
            reporter: 'spec',
            compilers: {
                ts: require('ts-node').register({
                    compiler: helper.getSettings().typescriptPath
                })
            }
        }))
        .once('end', function () {
            process.exit();
        })
        .on("error", (error) => {
            console.error(Util.formatError(error));
            process.exit(1)
        });
}

export default function Styles() {
    let settings = helper.getSettings();
    let bootstrapperBasePath = (settings.bootstrapperStyles) ? settings.bootstrapperStyles :
        path.resolve(process.cwd(), settings.targets, helper.getCurrentTarget());

    let bootstrapperPath = path.resolve(bootstrapperBasePath, 'bootstrapper.scss');
    if (!fs.existsSync(bootstrapperPath)) {
        console.warn("Styles bootstrapper not found at path", bootstrapperPath, ", skipping styles build process.");
        return Promise.resolve();
    }

    let stream = gulp.src(bootstrapperPath);

    function bundleRelease(stream) {
        return stream
            .pipe(concat('main.css'))
            .pipe(applySass())
            .pipe(autoprefixer({browsers: settings.autoprefixer}))
            .pipe(minify())
            .pipe(gulp.dest(helper.getTempFolder() + '/css'));
    }

    function bundleDevelopment(stream) {
        return stream
            .pipe(sourcemaps.init())
            .pipe(concat('main.css'))
            .pipe(applySass())
            .pipe(autoprefixer({browsers: settings.autoprefixerRules}))
            .pipe(sourcemaps.write())
            .pipe(gulp.dest(helper.getDistFolder() + '/css'))
            .pipe(refresh({
                start: helper.isWatching(),
                port: settings.liveReloadPort
            }));
    }

    function applySass() {
        return sass({
            importer: moduleImporter({basedir: process.cwd()})
        }).on('error', sass.logError)
    }

    return helper.isRelease() ? bundleRelease(stream) : bundleDevelopment(stream);
}

export default function Images() {
    let settings = helper.getSettings();
    return gulp.src(settings.images + '/**/*')
        .pipe(gulp.dest(path.join(helper.getTempFolder(), settings.images)));
}

export default function CopyIndex() {
    let stream = gulp.src('index.html');
    if (helper.isWatching())
        stream = stream.pipe(embedlr({ port: helper.getSettings().liveReloadPort}));
    return stream.pipe(gulp.dest(helper.getTempFolder()));
}