Which limits the execution rate by a specific amount of milliseconds, requestAnimationFrame or the current tick.

for specific timeout

throttle.timeout(fn, ms) || throttle(fn, ms)

for requestAnimationFrame

throttle.frame(fn)

current tick

throttle.immediate(fn) || throttle(fn)

Which runs the original function after the debounced function is not being called for a specific amount of milliseconds. Second argument to call the function when the debounced version is invoked.

debounce(fn, true / false)

Wondering if it would be wise to look at this instead of MooTools for the real world.

Because prime.create uses native ES5 Object.create when available it will support prime.create(null), useful for creating blank data objects, in newer environments but not older environments. Also because it uses Object.create in newer environments it will support a second descriptors argument, but not in older environments.

Currently Prime's ES5 String#trim fallback is pretty basic. There are known issues with using a regexp and \s. See ES5Shim's String#string implementation here:
kriskowal/es5-shim/es5-shim.js#L899-L918

Hi,

if a create a Prime that is only used as a mixin for other primes, it seems, that "direct" variables of this prime are instantiated correctly, but variables inside an object in this prime are mixed, as they were static.

Look at these example please, to understand correctly, what i mean:

var prime = require('prime');

var Counter = prime({
    counterVariable: 0,
    counterObject: {
        anotherCounterVariable: 0
    }, 
    raiseCounters: function() {
        this.counterVariable++;
        this.counterObject.anotherCounterVariable++;

        this.logCounters();
    }, 
    logCounters: function() {
        console.log('Counters', this.counterVariable, this.counterObject.anotherCounterVariable);
    }
});

var Foo = prime({
    mixin: Counter
});

var Bar = prime({
    mixin: Counter
});

var foo = new Foo();
var bar = new Bar();

foo.raiseCounters();
bar.raiseCounters();

foo.raiseCounters();
bar.raiseCounters();

the output in console is:

Counters 1 1
Counters 1 2
Counters 2 3
Counters 2 4

SocounterVariable is instantiated and mixed in correctly in the different Primes.
But counterObject.anotherCounterVariable stays static over the different Primes "Foo" and "Bar".

Is this a bug? Or should we tread it like an undocumentet feature? I dont think, that this is a good behaviour of Prime-mixin...

The expected behavior of object.keys would be to follow ES5 Object.keys and get the keys of only the own-enumerable properties of an object.

I'm 99% sure that:

# prime/map

Simple WeakMap implementation.

Ought to be:

# prime/map

Simple Map implementation.

Fix engrish. Make it better to understand…

Related to #15, Prime currently relies on prime.each for many of its object and Map methods when it should be using something that iterates over own-enumerable properties instead to be consistent with array counterparts behaviors.

Is there any plan to support method modifiers, such as in Joose, for example?

Avoiding ES5 array methods gives you better performance, portability, and the ability to add custom features.

Prime's current implementation relies on the presence of a native method first, which means if the method is shimmed incorrectly (which happens all the time) code built on Prime will be affected. Libs like NWMatcher, Dojo, YUI, Ember, and Lo-Dash detect and avoid shims increasing their portability because they can be used in environments which devs may not entirely control.

Because Prime is native first, its fallbacks must also follow spec or introduce cross-browser inconsistencies. Following spec cripples the perf of its fallbacks too because they have to do the (i in this) checks. Even if Prime follows the ES5 spec it still falls to cross-browser inconsistencies of what various engines consider sparse (IE < 9 will consider var a = ['', undefined, null] sparse, and other engines won't).

Because it's not limited to the ES5 specification of Array#map it can customize how callbacks are handled allowing for syntax like _.map(users 'username') to return an array of each user's username property value. Also notice it avoids .call in the loop by only performing the thisArg binding if it's passed. Finally, it fast paths arrays and falls back to the internal each function for objects, strings, and arguments objects. This allows it to fast path the common case while still providing consistent cross-environment support for the other cases.

Prime could use a lib like Lo-Dash for its low level utility methods. Lo-Dash covers issues like old IE's [[DontEnum]] bug that prime.each handles, but also fixes Firefox/WebKit/Opera prototype enumeration bugs when iterating functions, shift and splice bugs on array-like objects, function type checking bugs, and others.

Here is a list of API Prime could punt:

• prime.each => _.forIn
• prime.has => _.has
• array.count => _.size
• array.every => _.every
• array.filter => _.filter
• array.forEach => _.forEach
• array.indexOf => _.indexOf
• array.isArray => _.isArray
• array.lastIndexOf => _.lastIndexOf
• array.map => _.map
• array.some => _.some
• number.random => _.random
• number.times => _.times
• object.each => _.forIn
• object.filter => _.pick
• object.keys => _.keys
• object.map => _.assign
• object.values => _.values
• type => _.isArguments, _.isArray, _.isBoolean, _.isDate, _.isFunction, _.isRegExp

"Collections" methods, including _.every and _.some, will also work with strings, array-like objects and Object objects.

There's also support for intuitive chaining as well and has something similar to Prime's implement through _.mixin.

Prime would also get support for

• _.bind, _.clone, _.cloneDeep, _.defaults, _.extend, _.isFinite, _.isNaN, _.isObject, _.isPlainObject, _.merge, _.partial, _.partialRight, _.reduce, _.reduceRight, and lots of other methods.

You can leverage custom builds to include the methods and exports needed.

The indexOf ES5 array method should check (i in this) in its if check.

The NPM title of Prime is:

prime, an OOP JavaScript library for node and the web.

How exactly is this library for the web?

Because it's not AMD compliant and also not available to Bower (or something equivalent).

Went searching for Prime and found http://inversoft.github.io/prime.js/ as the top several results.

As we can see here: https://github.com/mootools/prime/blob/master/util/shell.js#L6 tabs suck.
Also it would be great to be consistent with the codestyle universally adopted by the nodejs community.

Modern minifiers will actually do things like "a,b,c".split(",") for you, when it's appropriate, so it's no longer required to be performed manually in the source.

There is a typo in package.json "description" field:
"javascript" should be "JavaScript".