• Version 3.1.0
  • Published
  • 281 kB
  • 8 dependencies
  • MIT license


npm i gulptraum
yarn add gulptraum
pnpm add gulptraum


Smart task generator for gulp to get a build pipeline and more in seconds.



variable cli

const cli: { generate: typeof generate; name: string; help: string };

    variable copy

    const copy: {
    generate: typeof generate;
    name: string;
    help: string;
    excludeTaskFromCli: boolean;

      variable DefaultBuildSystemConfig

      const DefaultBuildSystemConfig: IBuildSystemConfiguration<IBuildSystemPathsConfiguration>;

        variable help

        const help: {
        generate: typeof generate;
        name: string;
        help: string;
        excludeTaskFromCli: boolean;

          variable prepare_release

          const prepare_release: { generate: typeof generate; name: string; help: string };

            variable release

            const release: { generate: typeof generate; name: string; help: string };

              variable tasks

              const tasks: { generate: typeof generate; name: string; help: string };


                class BuildSystem

                class BuildSystem implements IBuildSystem {}


                  constructor(config: IBuildSystemConfiguration<IBuildSystemPathsConfiguration>);

                    property cli

                    cli: any;

                      property config

                      config: IBuildSystemConfiguration<IBuildSystemPathsConfiguration>;

                        property gulp

                        gulp: any;

                          property gulpAdapter

                          gulpAdapter: IGulpVersionAdapter;

                            property pluginConfigs

                            pluginConfigs: Map<string, IPluginConfiguration<IBuildSystemPathsConfiguration>>;

                              property plugins

                              plugins: Map<string, IGulptraumPlugin>;

                                property tasks

                                readonly tasks: string[];

                                  method initialize

                                  initialize: () => void;

                                    method registerPlugin

                                    registerPlugin: (
                                    name: string,
                                    plugin: IGulptraumPlugin,
                                    config: IPluginConfiguration,
                                    priority?: number
                                    ) => IBuildSystem;

                                      method registerTasks

                                      registerTasks: (externalGulp?: any) => void;

                                        method task

                                        task: (
                                        taskName: string,
                                        config: ITaskConfiguration,
                                        taskCallback: Function
                                        ) => void;


                                          interface IBuildSystem

                                          interface IBuildSystem {}

                                            interface IBuildSystem

                                            interface IBuildSystem {}

                                              interface IBuildSystemConfiguration

                                              interface IBuildSystemConfiguration<
                                              T extends IBuildSystemPathsConfiguration = IBuildSystemPathsConfiguration
                                              > {}

                                                property backupSetupFiles

                                                backupSetupFiles?: boolean;

                                                  property conventionalTasks

                                                  conventionalTasks?: {
                                                  [taskName: string]: IConventionalTaskConfiguration;

                                                    property fullPackageName

                                                    fullPackageName?: string;

                                                      property packageName

                                                      packageName?: string;

                                                        property paths

                                                        paths?: T;

                                                          property plugins

                                                          plugins?: {
                                                          [pluginName: string]: IPluginConfiguration;

                                                            property suppressErrors

                                                            suppressErrors?: false;

                                                              interface IBuildSystemPathsConfiguration

                                                              interface IBuildSystemPathsConfiguration {}

                                                                property changelog

                                                                changelog: string;

                                                                  property doc

                                                                  doc: string;

                                                                    property output

                                                                    output: string;

                                                                      property root

                                                                      root: string;

                                                                        property setup

                                                                        setup: string;

                                                                          property source

                                                                          source: string;

                                                                            property testOutput

                                                                            testOutput: string;

                                                                              property tests

                                                                              tests: string;

                                                                                interface ICliTaskArguments

                                                                                interface ICliTaskArguments {}

                                                                                  property options

                                                                                  options: {
                                                                                  [optionKey: string]: string;

                                                                                    interface IConfigurationHook

                                                                                    interface IConfigurationHook {}

                                                                                      call signature

                                                                                      (buildSystemConfig: IBuildSystemConfiguration): IPluginConfiguration;

                                                                                        interface IConventionalTaskConfiguration

                                                                                        interface IConventionalTaskConfiguration {}

                                                                                          property help

                                                                                          help?: string;

                                                                                            property tasksAfter

                                                                                            tasksAfter?: Array<string>;

                                                                                              property tasksBefore

                                                                                              tasksBefore?: Array<string>;

                                                                                                interface IGroupedPluginKeys

                                                                                                interface IGroupedPluginKeys {}

                                                                                                  index signature

                                                                                                  [priority: number]: Array<string>;

                                                                                                    interface IGulptraumHook

                                                                                                    interface IGulptraumHook {}

                                                                                                      call signature

                                                                                                      (gulp: any, config: any, gulptraum: IBuildSystem): void;

                                                                                                        interface IGulptraumPlugin

                                                                                                        interface IGulptraumPlugin {}

                                                                                                          property getDefaultConfig

                                                                                                          getDefaultConfig: IConfigurationHook;

                                                                                                            property initializePlugin

                                                                                                            initializePlugin: IGulptraumHook;

                                                                                                              interface IGulptraumTypeScriptPluginConfiguration

                                                                                                              interface IGulptraumTypeScriptPluginConfiguration extends IPluginConfiguration {}

                                                                                                                interface IGulpVersionAdapter

                                                                                                                interface IGulpVersionAdapter {}

                                                                                                                  method getGulpTasks

                                                                                                                  getGulpTasks: () => Array<string>;

                                                                                                                    method isTaskRegistered

                                                                                                                    isTaskRegistered: (taskName: string) => boolean;

                                                                                                                      method registerConventionalTask

                                                                                                                      registerConventionalTask: (
                                                                                                                      taskName: string,
                                                                                                                      taskConfig: any,
                                                                                                                      buildTasks: Array<Array<string>>
                                                                                                                      ) => void;

                                                                                                                        method registerGulpTask

                                                                                                                        registerGulpTask: (taskName: string, taskCallback: Function) => void;

                                                                                                                          method runTask

                                                                                                                          runTask: (taskName: string, taskCallback: Function) => void;

                                                                                                                            interface IPathsConfiguration

                                                                                                                            interface IPathsConfiguration {}

                                                                                                                              index signature

                                                                                                                              [pathName: string]: string;

                                                                                                                                interface IPluginConfiguration

                                                                                                                                interface IPluginConfiguration<
                                                                                                                                T extends IBuildSystemPathsConfiguration = IBuildSystemPathsConfiguration
                                                                                                                                > extends IBuildSystemConfiguration<T> {}

                                                                                                                                  property pluginName

                                                                                                                                  pluginName: string;

                                                                                                                                    property priority

                                                                                                                                    priority?: number;

                                                                                                                                      interface ITaskConfiguration

                                                                                                                                      interface ITaskConfiguration {}

                                                                                                                                        property help

                                                                                                                                        help: string;

                                                                                                                                          Package Files (10)

                                                                                                                                          Dependencies (8)

                                                                                                                                          Dev Dependencies (9)

                                                                                                                                          Peer Dependencies (0)

                                                                                                                                          No peer dependencies.


                                                                                                                                          To add a badge like this badgeto your package's README, use the codes available below.

                                                                                                                                          You may also use to create a custom badge linking to

                                                                                                                                          • Markdown
                                                                                                                                          • HTML
                                                                                                                                            <a href=""><img src="" alt=""></a>