ig-types 6.9.3 → 6.10.0

package/Date.js

@@ -57,7 +57,7 @@ object.Mixin('DateMixin', 'soft', {
 		str = ' '+str
 		var c = 
 			(/[^a-z](m(illi)?(-)?s(ec(ond(s)?)?)?)$/i.test(str)
-		   			|| /^[0-9]*(\.[0-9]+)?$/.test(str) ) ? 
+		   			|| /^([0-9]*\.)?[0-9]+$/.test(str) ) ? 
 				1
 			: /[^a-z]s(ec(ond(s)?)?)?$/i.test(str) ? 
 				1000
@@ -75,6 +75,8 @@ object.Mixin('DateMixin', 'soft', {
 
 	isPeriod: function(str){
 		return !isNaN(this.str2ms(str)) },
+	isDateStr: function(str){
+		return !isNaN(new Date(str).valueOf()) },
 })
 
 

package/README.md

@@ -1872,8 +1872,8 @@ Add a value to the generator sequence at start/end.
     -> <generator>
 ```
 
-Value added by `.unshift(..)` will be yielded by `<generator>` "first", i.e. on _next_ call to `.next()`, regardless of the current generator state.
-
+Value added by `.unshift(..)` will be yielded by `<generator>` "first", i.e. on 
+_next_ call to `.next()`, regardless of the current generator state.
 
 
 #### `<generator>.promise()`
@@ -2035,6 +2035,7 @@ currently which may not be the first element in the sequence.
 Equivalents to [`<generator>`'s `.shift(..)`/`.pop(..)`/..](#generatorshift--generatorpop--generatorgshift--generatorgpop) 
 but returning a reusable `<func>`/`<Generator>`.
 
+
 #### `<generator>.unshift(..)` / `<generator>.push(..)`
 
 ```bnf

package/RegExp.js

@@ -23,7 +23,48 @@ object.Mixin('RegExpMixin', 'soft', {
 })
 
 
+var GROUP_PATERN =
+//module.GROUP_PATERN = /(^\(|[^\\]\()/g
+module.GROUP_PATERN = new RegExp([
+	'^\\(',
+	// non-escaped braces...
+	'[^\\\\]\\(',
+	// XXX ignore braces in ranges...
+	// XXX '\\[.*(.*\\]',
+].join('|'))
+
+// Pattern group introspection...
+var RegExpProtoMixin =
+module.RegExpProtoMixin =
+object.Mixin('RegExpProtoMixin', 'soft', {
+	// Format:
+	// 	[
+	// 		{
+	//			index: <index>,
+	//			name: <name>,
+	//			pattern: <string>,
+	//			offset: <offset>,
+	// 		},
+	// 		...
+	// 	]
+	// XXX cache this...
+	get groups(){
+		this.toString()
+			.matchAll(GROUP_PATERN)
+	},
+	get namedGroups(){
+		return this.groups
+			.reduce(function(res, e){
+				e.name
+					&& (res[name] = e)
+				return res }, {}) },
+	get groupCount(){
+		return this.groups.length },
+})
+
+
 RegExpMixin(RegExp)
+RegExpProtoMixin(RegExp.prototype)
 
 
 var quoteRegExp =

package/event.js

@@ -34,17 +34,17 @@ module.TRIGGER = module.EventCommand('TRIGGER')
 
 
 
-// Create an "eventfull" method...
+// Create an "eventful" method...
 //
 // The resulting method can be either called directly or via .trigger(..).
 // Handlrs can be bound to it via .on(..) and unbound via .off(..) and 
 // calling it will trigger the handlers either after the user func(..)
 // return or when the user calles the passed handler(..) function.
 //
-// 	Eventfull(name[, options])
+// 	Eventful(name[, options])
 // 		-> method
 //
-// 	Eventfull(name, func[, options])
+// 	Eventful(name, func[, options])
 // 		-> method
 //
 //
@@ -88,9 +88,9 @@ module.TRIGGER = module.EventCommand('TRIGGER')
 //
 // NOTE: calling handle(false) will exiplicitly disable calling the 
 // 		handlers for that call...
-var Eventfull =
-module.Eventfull =
-object.Constructor('Eventfull', {
+var Eventful =
+module.Eventful =
+object.Constructor('Eventful', {
 
 	handlerLocation: 'context',
 
@@ -189,7 +189,7 @@ object.Constructor('Eventfull', {
 })
 
 
-// Extends Eventfull(..) adding ability to bind events via the 
+// Extends Eventful(..) adding ability to bind events via the 
 // resulting method directly by passing it a function...
 //
 //	Event(name[, options])
@@ -225,7 +225,7 @@ object.Constructor('Eventfull', {
 // arg is a function or not...
 var Event =
 module.Event =
-object.Constructor('Event', Eventfull, {
+object.Constructor('Event', Eventful, {
 	toString: function(){
 		return this.orig_func ?
 			'Event '
@@ -241,7 +241,7 @@ object.Constructor('Event', Eventfull, {
 			// call the action...
 			: object.parentCall(Event.prototype.__call__, this, context, ...args)
 			// XXX workaround for above line -- remove when fully tested...
-			//: Eventfull.prototype.__call__.call(this, context, ...args)
+			//: Eventful.prototype.__call__.call(this, context, ...args)
 		return context }, 
 })
 
@@ -330,13 +330,13 @@ module.EventHandlerMixin = object.Mixin('EventHandlerMixin', {
 // 		instead...
 var EventDocMixin = 
 module.EventDocMixin = object.Mixin('EventDocMixin', {
-	get eventfull(){
+	get eventful(){
 		return object.deepKeys(this)
 			.filter(function(n){ 
 				// avoid triggering props...
 				return !object.values(this, n, function(){ return object.STOP }, true)[0].get
 					// XXX this is too strict...
-					&& (this[n] || {}).constructor === Eventfull}.bind(this)) },
+					&& (this[n] || {}).constructor === Eventful}.bind(this)) },
 	get events(){
 		return object.deepKeys(this)
 			.filter(function(n){ 

package/main.js

@@ -29,8 +29,11 @@ module.runner = require('./runner')
 
 // Shorthands...
 module.STOP = object.STOP
-// NOTE: this is a generic enough type to be accessible at the root...
+
+// frequently used stuff...
 module.Generator = module.generator.Generator
+// XXX doc...
+module.iter = module.generator.iter
 
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ig-types",
-  "version": "6.9.3",
+  "version": "6.10.0",
   "description": "Generic JavaScript types and type extensions...",
   "main": "main.js",
   "scripts": {

package/test.js

@@ -381,19 +381,19 @@ Events.cases({
 
 					// blank events...
 					bareEventBlank: assert(
-						events.Eventfull('bareEventBlank'), 
-						'.Eventfull(..): blank'),
+						events.Eventful('bareEventBlank'), 
+						'.Eventful(..): blank'),
 					eventBlank: assert(
 						events.Event('eventBlank'), 
 						'.Event(..): blank'),
 
 					// normal events...
-					bareEvent: assert(events.Eventfull('bareEvent', 
+					bareEvent: assert(events.Eventful('bareEvent', 
 						function(handle, ...args){
 							called['bareEvent-call'] = true
-							assert(handle(), '.Eventfull(..) -> handle(..)')
+							assert(handle(), '.Eventful(..) -> handle(..)')
 							return 'bareEvent'
-						}), '.Eventfull(..)'),
+						}), '.Eventful(..)'),
 					event: assert(events.Event('event', 
 						function(handle, ...args){
 							called['event-call'] = true
@@ -408,7 +408,7 @@ Events.cases({
 
 		// test event list...
 		assert.array(obj.events, ['event', 'eventBlank'], '.events')
-		assert.array(obj.eventfull, ['bareEvent', 'bareEventBlank'], '.eventfull')
+		assert.array(obj.eventful, ['bareEvent', 'bareEventBlank'], '.eventful')
 
 		// bind...
 		var bind = function(evt){
@@ -418,7 +418,7 @@ Events.cases({
 
 		;['moo', 
 				...obj.events,
-				...obj.eventfull]
+				...obj.eventful]
 			.forEach(bind)
 
 		assert(obj.event(function(evt, ...args){