

\href{https://github.com/node-base/base}{\texttt{  }} \hypertarget{md_sfcode_node_modules_base_README_autotoc_md3849}{}\doxysection{base $<$a href=\char`\"{}https\+://www.\+npmjs.\+com/package/base\char`\"{}$>$$<$img src=\char`\"{}https\+://img.\+shields.\+io/npm/v/base.\+svg?style=flat\char`\"{} alt=\char`\"{}\+NPM version\char`\"{}/$>$$<$/a$>$ $<$a href=\char`\"{}https\+://npmjs.\+org/package/base\char`\"{}$>$$<$img src=\char`\"{}https\+://img.\+shields.\+io/npm/dm/base.\+svg?style=flat\char`\"{} alt=\char`\"{}\+NPM monthly downloads\char`\"{}/$>$$<$/a$>$  $<$a href=\char`\"{}https\+://npmjs.\+org/package/base\char`\"{}$>$$<$img src=\char`\"{}https\+://img.\+shields.\+io/npm/dt/base.\+svg?style=flat\char`\"{} alt=\char`\"{}\+NPM total downloads\char`\"{}/$>$$<$/a$>$ $<$a href=\char`\"{}https\+://travis-\/ci.\+org/node-\/base/base\char`\"{}$>$$<$img src=\char`\"{}https\+://img.\+shields.\+io/travis/node-\/base/base.\+svg?style=flat\&label=\+Travis\char`\"{} alt=\char`\"{}\+Linux Build Status\char`\"{}/$>$$<$/a$>$}\label{md_sfcode_node_modules_base_README_autotoc_md3849}
\begin{quote}
base is the foundation for creating modular, unit testable and highly pluggable node.\+js applications, starting with a handful of common methods, like {\ttfamily set}, {\ttfamily get}, {\ttfamily del} and {\ttfamily use}. \end{quote}
\hypertarget{md_sfcode_node_modules_base_README_autotoc_md3850}{}\doxysubsection{Install}\label{md_sfcode_node_modules_base_README_autotoc_md3850}
Install with \href{https://www.npmjs.com/}{\texttt{ npm}}\+:


\begin{DoxyCode}{0}
\DoxyCodeLine{\$ npm install -\/-\/save base }

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_base_README_autotoc_md3851}{}\doxysubsection{What is Base?}\label{md_sfcode_node_modules_base_README_autotoc_md3851}
Base is a framework for rapidly creating high quality node.\+js applications, using plugins like building blocks.\hypertarget{md_sfcode_node_modules_base_README_autotoc_md3852}{}\doxysubsubsection{Guiding principles}\label{md_sfcode_node_modules_base_README_autotoc_md3852}
The core team follows these principles to help guide API decisions\+:


\begin{DoxyItemize}
\item {\bfseries{Compact API surface}}\+: The smaller the API surface, the easier the library will be to learn and use.
\item {\bfseries{Easy to extend}}\+: Implementors can use any npm package, and write plugins in pure Java\+Script. If you\textquotesingle{}re building complex apps, Base simplifies inheritance.
\item {\bfseries{Easy to test}}\+: No special setup should be required to unit test {\ttfamily Base} or base plugins
\end{DoxyItemize}\hypertarget{md_sfcode_node_modules_base_README_autotoc_md3853}{}\doxysubsubsection{Minimal API surface}\label{md_sfcode_node_modules_base_README_autotoc_md3853}
\href{\#api}{\texttt{ The API}} was designed to provide only the minimum necessary functionality for creating a useful application, with or without \href{\#plugins}{\texttt{ plugins}}.

{\bfseries{Base core}}

Base itself ships with only a handful of \href{\#api}{\texttt{ useful methods}}, such as\+:


\begin{DoxyItemize}
\item {\ttfamily .set}\+: for setting values on the instance
\item {\ttfamily .get}\+: for getting values from the instance
\item {\ttfamily .has}\+: to check if a property exists on the instance
\item {\ttfamily .define}\+: for setting non-\/enumerable values on the instance
\item {\ttfamily .use}\+: for adding plugins
\end{DoxyItemize}

{\bfseries{Be generic}}

When deciding on method to add or remove, we try to answer these questions\+:


\begin{DoxyEnumerate}
\item Will all or most Base applications need this method?
\item Will this method encourage practices or enforce conventions that are beneficial to implementors?
\item Can or should this be done in a plugin instead?
\end{DoxyEnumerate}\hypertarget{md_sfcode_node_modules_base_README_autotoc_md3854}{}\doxysubsubsection{Composability}\label{md_sfcode_node_modules_base_README_autotoc_md3854}
{\bfseries{Plugin system}}

It couldn\textquotesingle{}t be easier to extend Base with any features or custom functionality you can think of.

Base plugins are just functions that take an instance of {\ttfamily Base}\+:


\begin{DoxyCode}{0}
\DoxyCodeLine{var base = new Base();}
\DoxyCodeLine{}
\DoxyCodeLine{function plugin(base) \{}
\DoxyCodeLine{  // do plugin stuff, in pure JavaScript}
\DoxyCodeLine{\}}
\DoxyCodeLine{// use the plugin}
\DoxyCodeLine{base.use(plugin); }

\end{DoxyCode}


{\bfseries{Inheritance}}

Easily inherit Base using {\ttfamily .extend}\+:


\begin{DoxyCode}{0}
\DoxyCodeLine{var Base = require('base');}
\DoxyCodeLine{}
\DoxyCodeLine{function MyApp() \{}
\DoxyCodeLine{  Base.call(this);}
\DoxyCodeLine{\}}
\DoxyCodeLine{Base.extend(MyApp);}
\DoxyCodeLine{}
\DoxyCodeLine{var app = new MyApp();}
\DoxyCodeLine{app.set('a', 'b');}
\DoxyCodeLine{app.get('a');}
\DoxyCodeLine{//=> 'b'; }

\end{DoxyCode}


{\bfseries{Inherit or instantiate with a namespace}}

By default, the {\ttfamily .get}, {\ttfamily .set} and {\ttfamily .has} methods set and get values from the root of the {\ttfamily base} instance. You can customize this using the {\ttfamily .namespace} method exposed on the exported function. For example\+:


\begin{DoxyCode}{0}
\DoxyCodeLine{var Base = require('base');}
\DoxyCodeLine{// get and set values on the `base.cache` object}
\DoxyCodeLine{var base = Base.namespace('cache');}
\DoxyCodeLine{}
\DoxyCodeLine{var app = base();}
\DoxyCodeLine{app.set('foo', 'bar');}
\DoxyCodeLine{console.log(app.cache.foo);}
\DoxyCodeLine{//=> 'bar' }

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_base_README_autotoc_md3855}{}\doxysubsection{API}\label{md_sfcode_node_modules_base_README_autotoc_md3855}
{\bfseries{Usage}}


\begin{DoxyCode}{0}
\DoxyCodeLine{var Base = require('base');}
\DoxyCodeLine{var app = new Base();}
\DoxyCodeLine{app.set('foo', 'bar');}
\DoxyCodeLine{console.log(app.foo);}
\DoxyCodeLine{//=> 'bar' }

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_base_README_autotoc_md3856}{}\doxysubsubsection{$<$a href=\char`\"{}index.\+js\#\+L44\char`\"{}$>$\+Base$<$/a$>$}\label{md_sfcode_node_modules_base_README_autotoc_md3856}
Create an instance of {\ttfamily Base} with the given {\ttfamily config} and {\ttfamily options}.

{\bfseries{Params}}


\begin{DoxyItemize}
\item {\ttfamily config} $\ast$$\ast$\{Object\}$\ast$$\ast$\+: If supplied, this object is passed to \href{https://github.com/jonschlinkert/cache-base}{\texttt{ cache-\/base}} to merge onto the the instance upon instantiation.
\item {\ttfamily options} $\ast$$\ast$\{Object\}$\ast$$\ast$\+: If supplied, this object is used to initialize the {\ttfamily base.\+options} object.
\end{DoxyItemize}

{\bfseries{Example}}


\begin{DoxyCode}{0}
\DoxyCodeLine{// initialize with `config` and `options`}
\DoxyCodeLine{var app = new Base(\{isApp: true\}, \{abc: true\});}
\DoxyCodeLine{app.set('foo', 'bar');}
\DoxyCodeLine{}
\DoxyCodeLine{// values defined with the given `config` object will be on the root of the instance}
\DoxyCodeLine{console.log(app.baz); //=> undefined}
\DoxyCodeLine{console.log(app.foo); //=> 'bar'}
\DoxyCodeLine{// or use `.get`}
\DoxyCodeLine{console.log(app.get('isApp')); //=> true}
\DoxyCodeLine{console.log(app.get('foo')); //=> 'bar'}
\DoxyCodeLine{}
\DoxyCodeLine{// values defined with the given `options` object will be on `app.options}
\DoxyCodeLine{console.log(app.options.abc); //=> true }

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_base_README_autotoc_md3857}{}\doxysubsubsection{$<$a href=\char`\"{}index.\+js\#\+L107\char`\"{}$>$.\+is$<$/a$>$}\label{md_sfcode_node_modules_base_README_autotoc_md3857}
Set the given {\ttfamily name} on {\ttfamily app.\+\_\+name} and {\ttfamily app.\+is$\ast$} properties. Used for doing lookups in plugins.

{\bfseries{Params}}


\begin{DoxyItemize}
\item {\ttfamily name} $\ast$$\ast$\{String\}$\ast$$\ast$
\item {\ttfamily returns} $\ast$$\ast$\{Boolean\}$\ast$$\ast$
\end{DoxyItemize}

{\bfseries{Example}}


\begin{DoxyCode}{0}
\DoxyCodeLine{app.is('foo');}
\DoxyCodeLine{console.log(app.\_name);}
\DoxyCodeLine{//=> 'foo'}
\DoxyCodeLine{console.log(app.isFoo);}
\DoxyCodeLine{//=> true}
\DoxyCodeLine{app.is('bar');}
\DoxyCodeLine{console.log(app.isFoo);}
\DoxyCodeLine{//=> true}
\DoxyCodeLine{console.log(app.isBar);}
\DoxyCodeLine{//=> true}
\DoxyCodeLine{console.log(app.\_name);}
\DoxyCodeLine{//=> 'bar' }

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_base_README_autotoc_md3858}{}\doxysubsubsection{$<$a href=\char`\"{}index.\+js\#\+L145\char`\"{}$>$.\+is\+Registered$<$/a$>$}\label{md_sfcode_node_modules_base_README_autotoc_md3858}
Returns true if a plugin has already been registered on an instance.

Plugin implementors are encouraged to use this first thing in a plugin to prevent the plugin from being called more than once on the same instance.

{\bfseries{Params}}


\begin{DoxyItemize}
\item {\ttfamily name} $\ast$$\ast$\{String\}$\ast$$\ast$\+: The plugin name.
\item {\ttfamily register} $\ast$$\ast$\{Boolean\}$\ast$$\ast$\+: If the plugin if not already registered, to record it as being registered pass {\ttfamily true} as the second argument.
\item {\ttfamily returns} $\ast$$\ast$\{Boolean\}$\ast$$\ast$\+: Returns true if a plugin is already registered.
\end{DoxyItemize}

{\bfseries{Events}}


\begin{DoxyItemize}
\item {\ttfamily emits}\+: {\ttfamily plugin} Emits the name of the plugin being registered. Useful for unit tests, to ensure plugins are only registered once.
\end{DoxyItemize}

{\bfseries{Example}}


\begin{DoxyCode}{0}
\DoxyCodeLine{var base = new Base();}
\DoxyCodeLine{base.use(function(app) \{}
\DoxyCodeLine{  if (app.isRegistered('myPlugin')) return;}
\DoxyCodeLine{  // do stuff to `app`}
\DoxyCodeLine{\});}
\DoxyCodeLine{}
\DoxyCodeLine{// to also record the plugin as being registered}
\DoxyCodeLine{base.use(function(app) \{}
\DoxyCodeLine{  if (app.isRegistered('myPlugin', true)) return;}
\DoxyCodeLine{  // do stuff to `app`}
\DoxyCodeLine{\}); }

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_base_README_autotoc_md3859}{}\doxysubsubsection{$<$a href=\char`\"{}index.\+js\#\+L175\char`\"{}$>$.\+use$<$/a$>$}\label{md_sfcode_node_modules_base_README_autotoc_md3859}
Define a plugin function to be called immediately upon init. Plugins are chainable and expose the following arguments to the plugin function\+:


\begin{DoxyItemize}
\item {\ttfamily app}\+: the current instance of {\ttfamily Base}
\item {\ttfamily base}\+: the \href{\#base}{\texttt{ first ancestor instance}} of {\ttfamily Base}
\end{DoxyItemize}

{\bfseries{Params}}


\begin{DoxyItemize}
\item {\ttfamily fn} $\ast$$\ast$\{Function\}$\ast$$\ast$\+: plugin function to call
\item {\ttfamily returns} $\ast$$\ast$\{Object\}$\ast$$\ast$\+: Returns the item instance for chaining.
\end{DoxyItemize}

{\bfseries{Example}}


\begin{DoxyCode}{0}
\DoxyCodeLine{var app = new Base()}
\DoxyCodeLine{  .use(foo)}
\DoxyCodeLine{  .use(bar)}
\DoxyCodeLine{  .use(baz) }

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_base_README_autotoc_md3860}{}\doxysubsubsection{$<$a href=\char`\"{}index.\+js\#\+L197\char`\"{}$>$.\+define$<$/a$>$}\label{md_sfcode_node_modules_base_README_autotoc_md3860}
The {\ttfamily .define} method is used for adding non-\/enumerable property on the instance. Dot-\/notation is {\bfseries{not supported}} with {\ttfamily define}.

{\bfseries{Params}}


\begin{DoxyItemize}
\item {\ttfamily key} $\ast$$\ast$\{String\}$\ast$$\ast$\+: The name of the property to define.
\item {\ttfamily value} $\ast$$\ast$\{any\}$\ast$$\ast$
\item {\ttfamily returns} $\ast$$\ast$\{Object\}$\ast$$\ast$\+: Returns the instance for chaining.
\end{DoxyItemize}

{\bfseries{Example}}


\begin{DoxyCode}{0}
\DoxyCodeLine{// arbitrary `render` function using lodash `template`}
\DoxyCodeLine{app.define('render', function(str, locals) \{}
\DoxyCodeLine{  return \_.template(str)(locals);}
\DoxyCodeLine{\}); }

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_base_README_autotoc_md3861}{}\doxysubsubsection{$<$a href=\char`\"{}index.\+js\#\+L222\char`\"{}$>$.\+mixin$<$/a$>$}\label{md_sfcode_node_modules_base_README_autotoc_md3861}
Mix property {\ttfamily key} onto the Base prototype. If base is inherited using {\ttfamily Base.\+extend} this method will be overridden by a new {\ttfamily mixin} method that will only add properties to the prototype of the inheriting application.

{\bfseries{Params}}


\begin{DoxyItemize}
\item {\ttfamily key} $\ast$$\ast$\{String\}$\ast$$\ast$
\item {\ttfamily val} $\ast$$\ast$\{Object$\vert$\+Array\}$\ast$$\ast$
\item {\ttfamily returns} $\ast$$\ast$\{Object\}$\ast$$\ast$\+: Returns the {\ttfamily base} instance for chaining.
\end{DoxyItemize}

{\bfseries{Example}}


\begin{DoxyCode}{0}
\DoxyCodeLine{app.mixin('foo', function() \{}
\DoxyCodeLine{  // do stuff}
\DoxyCodeLine{\}); }

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_base_README_autotoc_md3862}{}\doxysubsubsection{$<$a href=\char`\"{}index.\+js\#\+L268\char`\"{}$>$.\+base$<$/a$>$}\label{md_sfcode_node_modules_base_README_autotoc_md3862}
Getter/setter used when creating nested instances of {\ttfamily Base}, for storing a reference to the first ancestor instance. This works by setting an instance of {\ttfamily Base} on the {\ttfamily parent} property of a \char`\"{}child\char`\"{} instance. The {\ttfamily base} property defaults to the current instance if no {\ttfamily parent} property is defined.

{\bfseries{Example}}


\begin{DoxyCode}{0}
\DoxyCodeLine{// create an instance of `Base`, this is our first ("{}base"{}) instance}
\DoxyCodeLine{var first = new Base();}
\DoxyCodeLine{first.foo = 'bar'; // arbitrary property, to make it easier to see what's happening later}
\DoxyCodeLine{}
\DoxyCodeLine{// create another instance}
\DoxyCodeLine{var second = new Base();}
\DoxyCodeLine{// create a reference to the first instance (`first`)}
\DoxyCodeLine{second.parent = first;}
\DoxyCodeLine{}
\DoxyCodeLine{// create another instance}
\DoxyCodeLine{var third = new Base();}
\DoxyCodeLine{// create a reference to the previous instance (`second`)}
\DoxyCodeLine{// repeat this pattern every time a "{}child"{} instance is created}
\DoxyCodeLine{third.parent = second;}
\DoxyCodeLine{}
\DoxyCodeLine{// we can always access the first instance using the `base` property}
\DoxyCodeLine{console.log(first.base.foo);}
\DoxyCodeLine{//=> 'bar'}
\DoxyCodeLine{console.log(second.base.foo);}
\DoxyCodeLine{//=> 'bar'}
\DoxyCodeLine{console.log(third.base.foo);}
\DoxyCodeLine{//=> 'bar'}
\DoxyCodeLine{// and now you know how to get to third base ;) }

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_base_README_autotoc_md3863}{}\doxysubsubsection{$<$a href=\char`\"{}index.\+js\#\+L293\char`\"{}$>$\#use$<$/a$>$}\label{md_sfcode_node_modules_base_README_autotoc_md3863}
Static method for adding global plugin functions that will be added to an instance when created.

{\bfseries{Params}}


\begin{DoxyItemize}
\item {\ttfamily fn} $\ast$$\ast$\{Function\}$\ast$$\ast$\+: Plugin function to use on each instance.
\item {\ttfamily returns} $\ast$$\ast$\{Object\}$\ast$$\ast$\+: Returns the {\ttfamily Base} constructor for chaining
\end{DoxyItemize}

{\bfseries{Example}}


\begin{DoxyCode}{0}
\DoxyCodeLine{Base.use(function(app) \{}
\DoxyCodeLine{  app.foo = 'bar';}
\DoxyCodeLine{\});}
\DoxyCodeLine{var app = new Base();}
\DoxyCodeLine{console.log(app.foo);}
\DoxyCodeLine{//=> 'bar' }

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_base_README_autotoc_md3864}{}\doxysubsubsection{$<$a href=\char`\"{}index.\+js\#\+L337\char`\"{}$>$\#extend$<$/a$>$}\label{md_sfcode_node_modules_base_README_autotoc_md3864}
Static method for inheriting the prototype and static methods of the {\ttfamily Base} class. This method greatly simplifies the process of creating inheritance-\/based applications. See \href{https://github.com/jonschlinkert/static-extend}{\texttt{ static-\/extend}} for more details.

{\bfseries{Params}}


\begin{DoxyItemize}
\item {\ttfamily Ctor} $\ast$$\ast$\{Function\}$\ast$$\ast$\+: constructor to extend
\item {\ttfamily methods} $\ast$$\ast$\{Object\}$\ast$$\ast$\+: Optional prototype properties to mix in.
\item {\ttfamily returns} $\ast$$\ast$\{Object\}$\ast$$\ast$\+: Returns the {\ttfamily Base} constructor for chaining
\end{DoxyItemize}

{\bfseries{Example}}


\begin{DoxyCode}{0}
\DoxyCodeLine{var extend = cu.extend(Parent);}
\DoxyCodeLine{Parent.extend(Child);}
\DoxyCodeLine{}
\DoxyCodeLine{// optional methods}
\DoxyCodeLine{Parent.extend(Child, \{}
\DoxyCodeLine{  foo: function() \{\},}
\DoxyCodeLine{  bar: function() \{\}}
\DoxyCodeLine{\}); }

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_base_README_autotoc_md3865}{}\doxysubsubsection{$<$a href=\char`\"{}index.\+js\#\+L379\char`\"{}$>$\#mixin$<$/a$>$}\label{md_sfcode_node_modules_base_README_autotoc_md3865}
Used for adding methods to the {\ttfamily Base} prototype, and/or to the prototype of child instances. When a mixin function returns a function, the returned function is pushed onto the {\ttfamily .mixins} array, making it available to be used on inheriting classes whenever {\ttfamily Base.\+mixins()} is called (e.\+g. {\ttfamily Base.\+mixins(\+Child)}).

{\bfseries{Params}}


\begin{DoxyItemize}
\item {\ttfamily fn} $\ast$$\ast$\{Function\}$\ast$$\ast$\+: Function to call
\item {\ttfamily returns} $\ast$$\ast$\{Object\}$\ast$$\ast$\+: Returns the {\ttfamily Base} constructor for chaining
\end{DoxyItemize}

{\bfseries{Example}}


\begin{DoxyCode}{0}
\DoxyCodeLine{Base.mixin(function(proto) \{}
\DoxyCodeLine{  proto.foo = function(msg) \{}
\DoxyCodeLine{    return 'foo ' + msg;}
\DoxyCodeLine{  \};}
\DoxyCodeLine{\}); }

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_base_README_autotoc_md3866}{}\doxysubsubsection{$<$a href=\char`\"{}index.\+js\#\+L401\char`\"{}$>$\#mixins$<$/a$>$}\label{md_sfcode_node_modules_base_README_autotoc_md3866}
Static method for running global mixin functions against a child constructor. Mixins must be registered before calling this method.

{\bfseries{Params}}


\begin{DoxyItemize}
\item {\ttfamily Child} $\ast$$\ast$\{Function\}$\ast$$\ast$\+: Constructor function of a child class
\item {\ttfamily returns} $\ast$$\ast$\{Object\}$\ast$$\ast$\+: Returns the {\ttfamily Base} constructor for chaining
\end{DoxyItemize}

{\bfseries{Example}}


\begin{DoxyCode}{0}
\DoxyCodeLine{Base.extend(Child);}
\DoxyCodeLine{Base.mixins(Child); }

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_base_README_autotoc_md3867}{}\doxysubsubsection{$<$a href=\char`\"{}index.\+js\#\+L420\char`\"{}$>$\#inherit$<$/a$>$}\label{md_sfcode_node_modules_base_README_autotoc_md3867}
Similar to {\ttfamily util.\+inherit}, but copies all static properties, prototype properties, and getters/setters from {\ttfamily Provider} to {\ttfamily Receiver}. See \href{https://github.com/jonschlinkert/class-utils\#inherit}{\texttt{ class-\/utils}} for more details.

{\bfseries{Params}}


\begin{DoxyItemize}
\item {\ttfamily Receiver} $\ast$$\ast$\{Function\}$\ast$$\ast$\+: Receiving (child) constructor
\item {\ttfamily Provider} $\ast$$\ast$\{Function\}$\ast$$\ast$\+: Providing (parent) constructor
\item {\ttfamily returns} $\ast$$\ast$\{Object\}$\ast$$\ast$\+: Returns the {\ttfamily Base} constructor for chaining
\end{DoxyItemize}

{\bfseries{Example}}


\begin{DoxyCode}{0}
\DoxyCodeLine{Base.inherit(Foo, Bar); }

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_base_README_autotoc_md3868}{}\doxysubsection{In the wild}\label{md_sfcode_node_modules_base_README_autotoc_md3868}
The following node.\+js applications were built with {\ttfamily Base}\+:


\begin{DoxyItemize}
\item \href{https://github.com/assemble/assemble}{\texttt{ assemble}}
\item \href{https://github.com/verbose/verb}{\texttt{ verb}}
\item \href{https://github.com/generate/generate}{\texttt{ generate}}
\item \href{https://github.com/jonschlinkert/scaffold}{\texttt{ scaffold}}
\item \href{https://github.com/jonschlinkert/boilerplate}{\texttt{ boilerplate}}
\end{DoxyItemize}\hypertarget{md_sfcode_node_modules_base_README_autotoc_md3869}{}\doxysubsection{Test coverage}\label{md_sfcode_node_modules_base_README_autotoc_md3869}

\begin{DoxyCode}{0}
\DoxyCodeLine{Statements   : 98.91\% ( 91/92 )}
\DoxyCodeLine{Branches     : 92.86\% ( 26/28 )}
\DoxyCodeLine{Functions    : 100\% ( 17/17 )}
\DoxyCodeLine{Lines        : 98.9\% ( 90/91 ) }

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_base_README_autotoc_md3870}{}\doxysubsection{History}\label{md_sfcode_node_modules_base_README_autotoc_md3870}
\hypertarget{md_sfcode_node_modules_base_README_autotoc_md3871}{}\doxysubsubsection{v0.\+11.\+2}\label{md_sfcode_node_modules_base_README_autotoc_md3871}

\begin{DoxyItemize}
\item fixes \href{https://github.com/micromatch/micromatch/issues/99}{\texttt{ https\+://github.\+com/micromatch/micromatch/issues/99}}
\end{DoxyItemize}\hypertarget{md_sfcode_node_modules_base_README_autotoc_md3872}{}\doxysubsubsection{v0.\+11.\+0}\label{md_sfcode_node_modules_base_README_autotoc_md3872}
{\bfseries{Breaking changes}}


\begin{DoxyItemize}
\item Static {\ttfamily .use} and {\ttfamily .run} methods are now non-\/enumerable
\end{DoxyItemize}\hypertarget{md_sfcode_node_modules_base_README_autotoc_md3873}{}\doxysubsubsection{v0.\+9.\+0}\label{md_sfcode_node_modules_base_README_autotoc_md3873}
{\bfseries{Breaking changes}}


\begin{DoxyItemize}
\item {\ttfamily .is} no longer takes a function, a string must be passed
\item all remaining {\ttfamily .debug} code has been removed
\item {\ttfamily app.\+\_\+namespace} was removed (related to {\ttfamily debug})
\item {\ttfamily .plugin}, {\ttfamily .use}, and {\ttfamily .define} no longer emit events
\item {\ttfamily .assert\+Plugin} was removed
\item {\ttfamily .lazy} was removed
\end{DoxyItemize}\hypertarget{md_sfcode_node_modules_base_README_autotoc_md3874}{}\doxysubsection{About}\label{md_sfcode_node_modules_base_README_autotoc_md3874}
\hypertarget{md_sfcode_node_modules_base_README_autotoc_md3875}{}\doxysubsubsection{Related projects}\label{md_sfcode_node_modules_base_README_autotoc_md3875}

\begin{DoxyItemize}
\item \href{https://www.npmjs.com/package/base-cwd}{\texttt{ base-\/cwd}}\+: Base plugin that adds a getter/setter for the current working directory. $\vert$ \href{https://github.com/node-base/base-cwd}{\texttt{ homepage}}
\item \href{https://www.npmjs.com/package/base-data}{\texttt{ base-\/data}}\+: adds a {\ttfamily data} method to base-\/methods. $\vert$ \href{https://github.com/node-base/base-data}{\texttt{ homepage}}
\item \href{https://www.npmjs.com/package/base-fs}{\texttt{ base-\/fs}}\+: base-\/methods plugin that adds vinyl-\/fs methods to your \textquotesingle{}base\textquotesingle{} application for working with the file… \href{https://github.com/node-base/base-fs}{\texttt{ more}} $\vert$ \href{https://github.com/node-base/base-fs}{\texttt{ homepage}}
\item \href{https://www.npmjs.com/package/base-generators}{\texttt{ base-\/generators}}\+: Adds project-\/generator support to your {\ttfamily base} application. $\vert$ \href{https://github.com/node-base/base-generators}{\texttt{ homepage}}
\item \href{https://www.npmjs.com/package/base-option}{\texttt{ base-\/option}}\+: Adds a few options methods to base, like {\ttfamily option}, {\ttfamily enable} and {\ttfamily disable}. See the readme… \href{https://github.com/node-base/base-option}{\texttt{ more}} $\vert$ \href{https://github.com/node-base/base-option}{\texttt{ homepage}}
\item \href{https://www.npmjs.com/package/base-pipeline}{\texttt{ base-\/pipeline}}\+: base-\/methods plugin that adds pipeline and plugin methods for dynamically composing streaming plugin pipelines. $\vert$ \href{https://github.com/node-base/base-pipeline}{\texttt{ homepage}}
\item \href{https://www.npmjs.com/package/base-pkg}{\texttt{ base-\/pkg}}\+: Plugin for adding a {\ttfamily pkg} method that exposes pkg-\/store to your base application. $\vert$ \href{https://github.com/node-base/base-pkg}{\texttt{ homepage}}
\item \href{https://www.npmjs.com/package/base-plugins}{\texttt{ base-\/plugins}}\+: Adds \textquotesingle{}smart plugin\textquotesingle{} support to your base application. $\vert$ \href{https://github.com/node-base/base-plugins}{\texttt{ homepage}}
\item \href{https://www.npmjs.com/package/base-questions}{\texttt{ base-\/questions}}\+: Plugin for base-\/methods that adds methods for prompting the user and storing the answers on… \href{https://github.com/node-base/base-questions}{\texttt{ more}} $\vert$ \href{https://github.com/node-base/base-questions}{\texttt{ homepage}}
\item \href{https://www.npmjs.com/package/base-store}{\texttt{ base-\/store}}\+: Plugin for getting and persisting config values with your base-\/methods application. Adds a \textquotesingle{}store\textquotesingle{} object… \href{https://github.com/node-base/base-store}{\texttt{ more}} $\vert$ \href{https://github.com/node-base/base-store}{\texttt{ homepage}}
\item \href{https://www.npmjs.com/package/base-task}{\texttt{ base-\/task}}\+: base plugin that provides a very thin wrapper around \href{https://github.com/doowb/composer}{\texttt{ https\+://github.\+com/doowb/composer}} for adding task methods to… \href{https://github.com/node-base/base-task}{\texttt{ more}} $\vert$ \href{https://github.com/node-base/base-task}{\texttt{ homepage}}
\end{DoxyItemize}\hypertarget{md_sfcode_node_modules_base_README_autotoc_md3876}{}\doxysubsubsection{Contributing}\label{md_sfcode_node_modules_base_README_autotoc_md3876}
Pull requests and stars are always welcome. For bugs and feature requests, \href{../../issues/new}{\texttt{ please create an issue}}.\hypertarget{md_sfcode_node_modules_base_README_autotoc_md3877}{}\doxysubsubsection{Contributors}\label{md_sfcode_node_modules_base_README_autotoc_md3877}
\tabulinesep=1mm
\begin{longtabu}spread 0pt [c]{*{2}{|X[-1]}|}
\hline
\PBS\centering \cellcolor{\tableheadbgcolor}\textbf{ {\bfseries{Commits}}   }&\PBS\centering \cellcolor{\tableheadbgcolor}\textbf{ {\bfseries{Contributor}}    }\\\cline{1-2}
\endfirsthead
\hline
\endfoot
\hline
\PBS\centering \cellcolor{\tableheadbgcolor}\textbf{ {\bfseries{Commits}}   }&\PBS\centering \cellcolor{\tableheadbgcolor}\textbf{ {\bfseries{Contributor}}    }\\\cline{1-2}
\endhead
141   &\href{https://github.com/jonschlinkert}{\texttt{ jonschlinkert}}    \\\cline{1-2}
30   &\href{https://github.com/doowb}{\texttt{ doowb}}    \\\cline{1-2}
3   &\href{https://github.com/charlike}{\texttt{ charlike}}    \\\cline{1-2}
1   &\href{https://github.com/criticalmash}{\texttt{ criticalmash}}    \\\cline{1-2}
1   &\href{https://github.com/wtgtybhertgeghgtwtg}{\texttt{ wtgtybhertgeghgtwtg}}   \\\cline{1-2}
\end{longtabu}
\hypertarget{md_sfcode_node_modules_base_README_autotoc_md3878}{}\doxysubsubsection{Building docs}\label{md_sfcode_node_modules_base_README_autotoc_md3878}
\+\_\+(This project\textquotesingle{}s readme.\+md is generated by \href{https://github.com/verbose/verb-generate-readme}{\texttt{ verb}}, please don\textquotesingle{}t edit the readme directly. Any changes to the readme must be made in the .verb.md readme template.)\+\_\+

To generate the readme, run the following command\+:


\begin{DoxyCode}{0}
\DoxyCodeLine{\$ npm install -\/g verbose/verb\#dev verb-\/generate-\/readme \&\& verb }

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_base_README_autotoc_md3879}{}\doxysubsubsection{Running tests}\label{md_sfcode_node_modules_base_README_autotoc_md3879}
Running and reviewing unit tests is a great way to get familiarized with a library and its API. You can install dependencies and run tests with the following command\+:


\begin{DoxyCode}{0}
\DoxyCodeLine{\$ npm install \&\& npm test }

\end{DoxyCode}
\hypertarget{md_sfcode_node_modules_base_README_autotoc_md3880}{}\doxysubsubsection{Author}\label{md_sfcode_node_modules_base_README_autotoc_md3880}
{\bfseries{Jon Schlinkert}}


\begin{DoxyItemize}
\item \href{https://github.com/jonschlinkert}{\texttt{ github/jonschlinkert}}
\item \href{https://twitter.com/jonschlinkert}{\texttt{ twitter/jonschlinkert}}
\end{DoxyItemize}\hypertarget{md_sfcode_node_modules_base_README_autotoc_md3881}{}\doxysubsubsection{License}\label{md_sfcode_node_modules_base_README_autotoc_md3881}
Copyright © 2017, \href{https://github.com/jonschlinkert}{\texttt{ Jon Schlinkert}}. Released under the \mbox{[}MIT License\mbox{]}(LICENSE).

\DoxyHorRuler{0}


{\itshape This file was generated by \href{https://github.com/verbose/verb-generate-readme}{\texttt{ verb-\/generate-\/readme}}, v0.\+6.\+0, on September 07, 2017.} 