From 4266909d85b16910cd89245d87cf62691ae54dfb Mon Sep 17 00:00:00 2001 From: koresar Date: Tue, 30 Jun 2015 00:25:14 +1000 Subject: [PATCH] stampit v2 update --- stampit/stampit-1.2.0.d.ts | 155 +++++++++++++ stampit/stampit-tests-1.2.0.ts | 168 ++++++++++++++ stampit/stampit-tests.ts | 69 +++--- stampit/stampit.d.ts | 410 ++++++++++++++++++++++----------- 4 files changed, 638 insertions(+), 164 deletions(-) create mode 100644 stampit/stampit-1.2.0.d.ts create mode 100644 stampit/stampit-tests-1.2.0.ts diff --git a/stampit/stampit-1.2.0.d.ts b/stampit/stampit-1.2.0.d.ts new file mode 100644 index 0000000000..8d46e74778 --- /dev/null +++ b/stampit/stampit-1.2.0.d.ts @@ -0,0 +1,155 @@ +// Type definitions for stampit +// Project: https://github.com/ericelliott/stampit +// Definitions by: Vasyl Boroviak +// Definitions: https://github.com/borisyankov/DefinitelyTyped + +declare var stampit: stampit.Stampit; + +declare module stampit { + interface Stampit { + /** + * Return a factory (akaStamp) function that will produce new objects using the + * prototypes that are passed in or composed. + * @param methods A map of method names and bodies for delegation. + * @param state A map of property names and values to clone for each new object. + * @param enclose A closure (function) used to create private data and privileged methods. + * */ + (methods?:{}, state?:{}, enclose?:{(...encloseArgs:any[]): void}[]):stampit.Stamp; + + /** + * Take two or more Stamps and combine them to produce a new Stamp. + * Combining overrides properties with last-in priority. + * @param stamps Stamps produced by stampit. + * @return A new Stamp made of all the given. + */ + compose(...stamps:Stamp[]): Stamp; + + /** + * Take a destination object followed by one or more source objects, + * and copy the source object properties to the destination object, + * with last in priority overrides. + * @param destination An object to copy properties to. + * @param source Objects to copy properties from. + * @return The destination object. + */ + mixIn(destination:any, ...source:any[]): any; + + /** + * Alias for mixIn. + * Take a destination object followed by one or more source objects, + * and copy the source object properties to the destination object, + * with last in priority overrides. + * @param destination An object to copy properties to. + * @param source Objects to copy properties from. + * @return The destination object. + */ + extend(destination:any, ...source:any[]): any; + + /** + * Check if an object is a Stamp. + * @param obj An object to check. + * @return true if the object is a Stamp; otherwise - false. + */ + isStamp(obj:any): boolean; + + /** + * Take an old-fashioned JS constructor and return a Stamp + * that you can freely compose with other Stamps. + * @param Constructor Old-fashioned constructor function. + * @return A new Stamp based on the given constructor. + */ + convertConstructor(Constructor:any): Stamp; + } + + /** + * A factory function that will produce new objects using the + * prototypes that are passed in or composed. + */ + export interface Stamp { + /** + * Just like calling stamp() invokes the stamp and returns a new object instance. + * @param state Properties you wish to set on the new objects. + * @param encloseArgs The remaining arguments are passed to all .enclose() functions. + * WARNING Avoid using two different .enclose() functions that expect different arguments. + * .enclose() functions that take arguments should not be considered safe to compose + * with other .enclose() functions that also take arguments. Taking arguments with + * an .enclose() function is an anti-pattern that should be avoided, when possible. + * @return A new object composed of the Stamps and prototypes provided. + */ + (state?:{}, ...encloseArgs:any[]): any; + + /** + * Just like calling stamp(), stamp.create() invokes the stamp and returns a new instance. + * @param state Properties you wish to set on the new objects. + * @param encloseArgs The remaining arguments are passed to all .enclose() functions. + * WARNING Avoid using two different .enclose() functions that expect different arguments. + * .enclose() functions that take arguments should not be considered safe to compose + * with other .enclose() functions that also take arguments. Taking arguments with + * an .enclose() function is an anti-pattern that should be avoided, when possible. + * @return A new object composed of the Stamps and prototypes provided. + */ + create(state?:{}, ...encloseArgs:any[]): any; + + /** + * An object map containing the fixed prototypes. + */ + fixed: Fixed; + + /** + * Add methods to the methods prototype. Chainable. + * @param methods Object(s) containing map of method names and bodies for delegation. + * @return Self. + */ + methods(...methods:{}[]): Stamp; + + /** + * Take n objects and add them to the state prototype. Changes `this` object. Chainable. + * @param states Object(s) containing map of property names and values to clone for each new object. + * @return Self. + */ + state(...states:{}[]): Stamp; + + /** + * Take n functions, an array of functions, or n objects and add the functions to the enclose prototype. + * Functions passed into .enclose() are called any time an object is instantiated. + * That happens when the stamp function is invoked, or when the .create() method is called. + * Changes `this` object. Chainable. + * @param functions Closures (functions) used to create private data and privileged methods. + * @return Self. + */ + enclose(...functions:{(...encloseArgs:any[]): void}[]): Stamp; + + /** + * Take n functions, an array of functions, or n objects and add the functions to the enclose prototype. + * Functions passed into .enclose() are called any time an object is instantiated. + * That happens when the stamp function is invoked, or when the .create() method is called. + * Changes `this` object. Chainable. + * @param methods Function properties of these objects will be treated as closure functions. + * @return Self. + */ + enclose(...methods:{}[]): Stamp; + + /** + * Take one or more Stamps and + * combine them with `this` to produce and return a new Stamp. + * Combining overrides properties with last-in priority. + * NOT chainable. + * @param stamps Stampit factories, aka Stamps. + * @return A new Stamp composed from arguments and `this`. + */ + compose(...stamps:Stamp[]): Stamp; + } + + /** + * An object map containing the fixed prototypes. + */ + interface Fixed { + methods: {}; + state: {}; + enclose: {(...encloseArgs:any[]): void}[]; + } +} + +declare module "stampit" { + export = stampit; +} \ No newline at end of file diff --git a/stampit/stampit-tests-1.2.0.ts b/stampit/stampit-tests-1.2.0.ts new file mode 100644 index 0000000000..ce404651a1 --- /dev/null +++ b/stampit/stampit-tests-1.2.0.ts @@ -0,0 +1,168 @@ +/// + +var a = stampit().enclose(() => { + var a = 'a'; + this.getA = () => { + return a; + }; +}); +a(); // Object -- so far so good. +a().getA(); // "a" + + +var b = stampit().enclose(function () { + var a = 'b'; + this.getB = function () { + return a; + }; +}); + + +var c = stampit.compose(a, b); +var foo = c(); // we won't throw this one away... +foo.getA(); // "a" +foo.getB(); // "b" + + +// Some more privileged methods, with some private data. +// Use stampit.mixIn() to make this feel declarative: +var availability = stampit().enclose(function () { + var isOpen = false; // private + + return stampit.mixIn(this, { + open: function open() { + isOpen = true; + return this; + }, + close: function close() { + isOpen = false; + return this; + }, + isOpen: function isOpenMethod() { + return isOpen; + } + }); +}); +// Hre's a mixin with public methods, and some state: +var membership = stampit({ + members: {}, + add: function (member: any) { + this.members[member.name] = member; + return this; + }, + getMember: function (name: any) { + return this.members[name]; + } + }, + { + members: {} + }); +// Let's set some defaults: +var defaults = stampit().state({ + name: 'The Saloon', + specials: 'Whisky, Gin, Tequila' +}); + +// Classical inheritance has nothing on this. No parent/child coupling. No deep inheritance hierarchies. +// Just good, clean code reusability. +var bar = stampit.compose(defaults, availability, membership); +// Note that you can override state on instantiation: +var myBar = bar({name: 'Moe\'s'}); +// Silly, but proves that everything is as it should be. +myBar.add({name: 'Homer' }).open().getMember('Homer'); + + + +var myStamp = stampit().methods({ + foo: function () { + return 'foo'; + }, + methodOverride: function () { + return false; + } +}).methods({ + bar: function () { + return 'bar' + }, + methodOverride: function () { + return true; + } +}); + +myStamp.state({ + foo: {bar: 'bar'}, + stateOverride: false +}).state({ + bar: 'bar', + stateOverride: true +}); + +myStamp.enclose(function () { + var secret = 'foo'; + + this.getSecret = function () { + return secret; + }; +}).enclose(function () { + this.a = true; +}).enclose({ + bar: function bar() { + this.b = true; + } +}, { + baz: function baz() { + this.c = true; + } +}); + +var obj = myStamp.create(); +obj.getSecret && obj.a && obj.b && obj.c; // true + +var newStamp = stampit(null, { defaultNum: 1 }).compose(myStamp); + + + +var obj1 = stampit().methods({ + a: function () { return 'a'; } +}, { + b: function () { return 'b'; } +}).create(); + +var obj2 = stampit().state({ + a: 'a' +}, { + b: 'b' +}).create(); + +var obj = defaults.compose(newStamp, membership, availability).create(); + + + +// The old constructor / class thing... +var Constructor = function Constructor() { + this.thing = 'initialized'; +}; +Constructor.prototype.foo = function foo() { return 'foo'; }; + +// The conversion +var oldskool = stampit.convertConstructor(Constructor); + +// A new stamp to compose with... +var newskool = stampit().methods({ + bar: function bar() { return 'bar'; } + // your methods here... +}).enclose(function () { + this.baz = 'baz'; +}); + +// Now you can compose those old constructors just like you could +// with any other stamp... +var myThing = stampit.compose(oldskool, newskool); + +var t = myThing(); + +t.thing; // 'initialized', + +t.foo(); // 'foo', + +t.bar(); // 'bar' diff --git a/stampit/stampit-tests.ts b/stampit/stampit-tests.ts index 4354461b7d..f813482d8f 100644 --- a/stampit/stampit-tests.ts +++ b/stampit/stampit-tests.ts @@ -1,7 +1,8 @@ /// +import stampit = require('./stampit.d'); -var a = stampit().enclose(() => { - var a = 'a'; +var a = stampit().init((options) => { + var a = options.args[0]; this.getA = () => { return a; }; @@ -10,7 +11,7 @@ a(); // Object -- so far so good. a().getA(); // "a" -var b = stampit().enclose(function () { +var b = stampit().init(function () { var a = 'b'; this.getB = function () { return a; @@ -26,7 +27,7 @@ foo.getB(); // "b" // Some more privileged methods, with some private data. // Use stampit.mixIn() to make this feel declarative: -var availability = stampit().enclose(function () { +var availability = stampit().init(function () { var isOpen = false; // private return stampit.mixIn(this, { @@ -43,22 +44,25 @@ var availability = stampit().enclose(function () { } }); }); -// Hre's a mixin with public methods, and some state: + +// Here's a mixin with public methods, and some refs: var membership = stampit({ + methods: { members: {}, - add: function (member: any) { + add: function (member:any) { this.members[member.name] = member; return this; }, - getMember: function (name: any) { + getMember: function (name:any) { return this.members[name]; } }, - { + refs: { members: {} - }); + } +}); // Let's set some defaults: -var defaults = stampit().state({ +var defaults = stampit().refs({ name: 'The Saloon', specials: 'Whisky, Gin, Tequila' }); @@ -66,11 +70,10 @@ var defaults = stampit().state({ // Classical inheritance has nothing on this. No parent/child coupling. No deep inheritance hierarchies. // Just good, clean code reusability. var bar = stampit.compose(defaults, availability, membership); -// Note that you can override state on instantiation: +// Note that you can override refs on instantiation: var myBar = bar({name: 'Moe\'s'}); // Silly, but proves that everything is as it should be. -myBar.add({name: 'Homer' }).open().getMember('Homer'); - +myBar.add({name: 'Homer'}).open().getMember('Homer'); var myStamp = stampit().methods({ @@ -89,23 +92,23 @@ var myStamp = stampit().methods({ } }); -myStamp.state({ +myStamp.refs({ foo: {bar: 'bar'}, - stateOverride: false -}).state({ + refsOverride: false +}).refs({ bar: 'bar', - stateOverride: true + refsOverride: true }); -myStamp.enclose(function () { +myStamp.init(function () { var secret = 'foo'; this.getSecret = function () { return secret; }; -}).enclose(function () { +}).init(function () { this.a = true; -}).enclose({ +}).init({ bar: function bar() { this.b = true; } @@ -118,17 +121,20 @@ myStamp.enclose(function () { var obj = myStamp.create(); obj.getSecret && obj.a && obj.b && obj.c; // true -var newStamp = stampit(null, { defaultNum: 1 }).compose(myStamp); - +var newStamp = stampit({refs: {defaultNum: 1}}).compose(myStamp); var obj1 = stampit().methods({ - a: function () { return 'a'; } + a: function () { + return 'a'; + } }, { - b: function () { return 'b'; } + b: function () { + return 'b'; + } }).create(); -var obj2 = stampit().state({ +var obj2 = stampit().refs({ a: 'a' }, { b: 'b' @@ -137,21 +143,24 @@ var obj2 = stampit().state({ var obj = defaults.compose(newStamp, membership, availability).create(); - // The old constructor / class thing... var Constructor = function Constructor() { this.thing = 'initialized'; }; -Constructor.prototype.foo = function foo() { return 'foo'; }; +Constructor.prototype.foo = function foo() { + return 'foo'; +}; // The conversion var oldskool = stampit.convertConstructor(Constructor); // A new stamp to compose with... var newskool = stampit().methods({ - bar: function bar() { return 'bar'; } + bar: function bar() { + return 'bar'; + } // your methods here... -}).enclose(function () { +}).init(function () { this.baz = 'baz'; }); @@ -165,4 +174,4 @@ t.thing; // 'initialized', t.foo(); // 'foo', -t.bar(); // 'bar' \ No newline at end of file +t.bar(); // 'bar' diff --git a/stampit/stampit.d.ts b/stampit/stampit.d.ts index 8d46e74778..e56035c4fa 100644 --- a/stampit/stampit.d.ts +++ b/stampit/stampit.d.ts @@ -1,155 +1,297 @@ -// Type definitions for stampit -// Project: https://github.com/ericelliott/stampit +// Type definitions for stampit 2.1 +// Project: https://github.com/stampit-org/stampit // Definitions by: Vasyl Boroviak // Definitions: https://github.com/borisyankov/DefinitelyTyped -declare var stampit: stampit.Stampit; +/** + * Function used as .init() argument. + */ +interface Init { + (ctx:Context): any | Promise; +} -declare module stampit { - interface Stampit { - /** - * Return a factory (akaStamp) function that will produce new objects using the - * prototypes that are passed in or composed. - * @param methods A map of method names and bodies for delegation. - * @param state A map of property names and values to clone for each new object. - * @param enclose A closure (function) used to create private data and privileged methods. - * */ - (methods?:{}, state?:{}, enclose?:{(...encloseArgs:any[]): void}[]):stampit.Stamp; +interface Promise { + then(resolve:(result: any) => any|Promise, reject:(reason: any | Error) => any|Promise): Promise +} - /** - * Take two or more Stamps and combine them to produce a new Stamp. - * Combining overrides properties with last-in priority. - * @param stamps Stamps produced by stampit. - * @return A new Stamp made of all the given. - */ - compose(...stamps:Stamp[]): Stamp; - - /** - * Take a destination object followed by one or more source objects, - * and copy the source object properties to the destination object, - * with last in priority overrides. - * @param destination An object to copy properties to. - * @param source Objects to copy properties from. - * @return The destination object. - */ - mixIn(destination:any, ...source:any[]): any; - - /** - * Alias for mixIn. - * Take a destination object followed by one or more source objects, - * and copy the source object properties to the destination object, - * with last in priority overrides. - * @param destination An object to copy properties to. - * @param source Objects to copy properties from. - * @return The destination object. - */ - extend(destination:any, ...source:any[]): any; - - /** - * Check if an object is a Stamp. - * @param obj An object to check. - * @return true if the object is a Stamp; otherwise - false. - */ - isStamp(obj:any): boolean; - - /** - * Take an old-fashioned JS constructor and return a Stamp - * that you can freely compose with other Stamps. - * @param Constructor Old-fashioned constructor function. - * @return A new Stamp based on the given constructor. - */ - convertConstructor(Constructor:any): Stamp; - } +/** + * The .init() function argument. + */ +interface Context { + /** + * The object which has been just instantiated. + */ + instance: any; /** - * A factory function that will produce new objects using the - * prototypes that are passed in or composed. + * The stamp the object has been instantiated with. */ - export interface Stamp { - /** - * Just like calling stamp() invokes the stamp and returns a new object instance. - * @param state Properties you wish to set on the new objects. - * @param encloseArgs The remaining arguments are passed to all .enclose() functions. - * WARNING Avoid using two different .enclose() functions that expect different arguments. - * .enclose() functions that take arguments should not be considered safe to compose - * with other .enclose() functions that also take arguments. Taking arguments with - * an .enclose() function is an anti-pattern that should be avoided, when possible. - * @return A new object composed of the Stamps and prototypes provided. - */ - (state?:{}, ...encloseArgs:any[]): any; + stamp: Stamp; - /** - * Just like calling stamp(), stamp.create() invokes the stamp and returns a new instance. - * @param state Properties you wish to set on the new objects. - * @param encloseArgs The remaining arguments are passed to all .enclose() functions. - * WARNING Avoid using two different .enclose() functions that expect different arguments. - * .enclose() functions that take arguments should not be considered safe to compose - * with other .enclose() functions that also take arguments. Taking arguments with - * an .enclose() function is an anti-pattern that should be avoided, when possible. - * @return A new object composed of the Stamps and prototypes provided. - */ - create(state?:{}, ...encloseArgs:any[]): any; + /** + * The arguments list passed to the stamp. + */ + args: any[]; +} - /** - * An object map containing the fixed prototypes. - */ - fixed: Fixed; +/** + * An object map containing the fixed prototypes. + */ +interface Fixed { + methods: {}; - /** - * Add methods to the methods prototype. Chainable. - * @param methods Object(s) containing map of method names and bodies for delegation. - * @return Self. - */ - methods(...methods:{}[]): Stamp; + /** + * @deprecated Use .refs() instead. + */ + state: {}; - /** - * Take n objects and add them to the state prototype. Changes `this` object. Chainable. - * @param states Object(s) containing map of property names and values to clone for each new object. - * @return Self. - */ - state(...states:{}[]): Stamp; + refs: {}; - /** - * Take n functions, an array of functions, or n objects and add the functions to the enclose prototype. - * Functions passed into .enclose() are called any time an object is instantiated. - * That happens when the stamp function is invoked, or when the .create() method is called. - * Changes `this` object. Chainable. - * @param functions Closures (functions) used to create private data and privileged methods. - * @return Self. - */ - enclose(...functions:{(...encloseArgs:any[]): void}[]): Stamp; + /** + * @deprecated Use .init() instead. + */ + enclose: Init[]; - /** - * Take n functions, an array of functions, or n objects and add the functions to the enclose prototype. - * Functions passed into .enclose() are called any time an object is instantiated. - * That happens when the stamp function is invoked, or when the .create() method is called. - * Changes `this` object. Chainable. - * @param methods Function properties of these objects will be treated as closure functions. - * @return Self. - */ - enclose(...methods:{}[]): Stamp; + init: Init[]; - /** - * Take one or more Stamps and - * combine them with `this` to produce and return a new Stamp. - * Combining overrides properties with last-in priority. - * NOT chainable. - * @param stamps Stampit factories, aka Stamps. - * @return A new Stamp composed from arguments and `this`. - */ - compose(...stamps:Stamp[]): Stamp; - } + props: {}; + + static: {}; +} + +interface Options { + /** + * A hash containing methods (functions) of any future created instance. + */ + methods?: {} | {}[]; + + /** + * A hash containing references to the object. This hash will be shallow mixed into any future created instance. + */ + refs?: {} | {}[]; + + /** + * Initialization function which will be called per each newly created instance. + */ + init?: Init | Init[]; + + /** + * Properties which will be deeply (but safely, no data override) merged into any future created instance. + */ + props?: {} | {}[]; + + /** + * Properties which will be mixed to the new and any other stamp which this stamp will be composed with. + */ + static?: {} | {}[]; +} + +/** + * A factory function that will produce new objects using the + * prototypes that are passed in or composed. + */ +interface Stamp { + /** + * Invokes the stamp and returns a new object instance. + * @param state Properties you wish to set on the new objects. + * @param encloseArgs The remaining arguments are passed to all .enclose() functions. + * WARNING Avoid using two different .enclose() functions that expect different arguments. + * .enclose() functions that take arguments should not be considered safe to compose + * with other .enclose() functions that also take arguments. Taking arguments with + * an .enclose() function is an anti-pattern that should be avoided, when possible. + * @return A new object composed of the Stamps and prototypes provided. + */ + (state?:{}, ...encloseArgs:any[]): any | Promise; + + /** + * Just like calling stamp(), stamp.create() invokes the stamp and returns a new instance. + * @param state Properties you wish to set on the new objects. + * @param encloseArgs The remaining arguments are passed to all .enclose() functions. + * WARNING Avoid using two different .enclose() functions that expect different arguments. + * .enclose() functions that take arguments should not be considered safe to compose + * with other .enclose() functions that also take arguments. Taking arguments with + * an .enclose() function is an anti-pattern that should be avoided, when possible. + * @return A new object composed of the Stamps and prototypes provided. + */ + create(state?:{}, ...encloseArgs:any[]): any | Promise; /** * An object map containing the fixed prototypes. */ - interface Fixed { - methods: {}; - state: {}; - enclose: {(...encloseArgs:any[]): void}[]; - } + fixed: Fixed; + + /** + * Add methods to the methods prototype. Creates and returns new Stamp. Chainable. + * @param methods Object(s) containing map of method names and bodies for delegation. + * @return A new Stamp. + */ + methods(...methods:{}[]): Stamp; + + /** + * Take n objects and add them to the state prototype. Creates and returns new Stamp. Chainable. + * @param states Object(s) containing map of property names and values to clone for each new object. + * @return A new Stamp. + */ + refs(...states:{}[]): Stamp; + + /** + * Take n objects and merge them (but safely, no data override) to the of any future created instance. + * Creates and returns new Stamp. Chainable. + * @param objects Object(s) to merge for each new object. + * @return A new Stamp. + */ + props(...objects:{}[]): Stamp; + + /** + * @deprecated Use .refs() instead. + */ + state(...states:{}[]): Stamp; + + /** + * @deprecated Use .init() instead. + */ + enclose(...functions:Init[]): Stamp; + + /** + * @deprecated Use .init() instead. + */ + enclose(...functions:{}[]): Stamp; + + /** + * Take n functions, an array of functions, or n objects and add the functions to the enclose prototype. + * Functions passed into .enclose() are called any time an object is instantiated. + * That happens when the stamp function is invoked, or when the .create() method is called. + * Creates and returns new Stamp. Chainable. + * @param functions Closures (functions) used to create private data and privileged methods. + * @return A new Stamp. + */ + init(...functions:Init[]): Stamp; + + /** + * Take n functions, an array of functions, or n objects and add the functions to the enclose prototype. + * Functions passed into .enclose() are called any time an object is instantiated. + * That happens when the stamp function is invoked, or when the .create() method is called. + * Creates and returns new Stamp. Chainable. + * @param functions Function properties of these objects will be treated as closure functions. + * @return A new Stamp. + */ + init(...functions:{}[]): Stamp; + + /** + * Take n objects and add them to a new stamp and any future stamp it composes with. + * Creates and returns new Stamp. Chainable. + * @param statics Object(s) containing map of property names and values to mixin into each new stamp. + * @return A new Stamp. + */ + static(...statics:{}[]): Stamp; + + /** + * Take one or more Stamps and + * combine them with `this` to produce and return a new Stamp. + * Combining overrides properties with last-in priority. + * NOT chainable. + * @param stamps Stampit factories, aka Stamps. + * @return A new Stamp composed from arguments and `this`. + */ + compose(...stamps:Stamp[]): Stamp; } -declare module "stampit" { - export = stampit; -} \ No newline at end of file +/** + * Return a factory (akaStamp) function that will produce new objects using the + * prototypes that are passed in or composed. + * @param {object} options Stampit options object containing refs, methods, init, props, and static. + * @param {object} options.methods A map of method names and bodies for delegation. + * @param {object} options.refs A map of property names and values to clone for each new object. + * @param {object} options.props A map of property names and values to clone for each new object. + * @param {function} options.init A closure(s) (function(s)) used to create private data and privileged methods. + * @param {object} options.static A map of properties to mixin into new and other stamp it will compose with. + * */ +declare function stampit(options?: Options): Stamp + +declare module stampit { + + /** + * A shortcut methods for stampit().methods() + * @param methods Object(s) containing map of method names and bodies for delegation. + * @return A new Stamp. + */ + export function methods(...methods:{}[]): Stamp; + + /** + * A shortcut methods for stampit().refs() + * @param states Object(s) containing map of property names and values to clone for each new object. + * @return A new Stamp. + */ + export function refs(...states:{}[]): Stamp; + + /** + * A shortcut methods for stampit().props() + * @param states Object(s) to merge for each new object. + * @return A new Stamp. + */ + export function props(...states:{}[]): Stamp; + + /** + * A shortcut methods for stampit().init() + * @param functions Closures (functions) used to create private data and privileged methods. + * @return A new Stamp. + */ + export function init(...functions:Init[]): Stamp; + + /** + * A shortcut methods for stampit().static() + * @param statics Object(s) containing map of property names and values to mixin into each new stamp (NOT OBJECT). + * @return A new Stamp. + */ + export function static(...statics:{}[]): Stamp; + + /** + * Take two or more Stamps and combine them to produce a new Stamp. + * Combining overrides properties with last-in priority. + * @param stamps Stamps produced by stampit. + * @return A new Stamp made of all the given. + */ + export function compose(...stamps:Stamp[]): Stamp; + + /** + * Take a destination object followed by one or more source objects, + * and copy the source object properties to the destination object, + * with last in priority overrides. + * @param destination An object to copy properties to. + * @param source Objects to copy properties from. + * @return The destination object. + */ + export function mixin(destination:any, ...source:any[]): any; + + /** + * Alias for mixin() + */ + export function mixIn(destination:any, ...source:any[]): any; + + /** + * Alias for mixin() + */ + export function extend(destination:any, ...source:any[]): any; + + /** + * Alias for mixin() + */ + export function assign(destination:any, ...source:any[]): any; + + /** + * Check if an object is a Stamp. + * @param obj An object to check. + * @return true if the object is a Stamp; otherwise - false. + */ + export function isStamp(obj:any): boolean; + + /** + * Take an old-fashioned JS constructor and return a Stamp + * that you can freely compose with other Stamps. + * @param Constructor Old-fashioned constructor function. + * @return A new Stamp based on the given constructor. + */ + export function convertConstructor(Constructor:any): Stamp; +} + +export = stampit;