ig-types 6.9.1 → 6.9.4

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/Map.js

@@ -16,6 +16,10 @@ var object = require('ig-object')
 var MapProtoMixin =
 module.MapProtoMixin =
 object.Mixin('MapProtoMixin', 'soft', {
+	iter: function*(){
+		for(var e of this){
+			yield e } },
+
 	// NOTE: we do not touch .__keys here as no renaming is ever done...
 	//
 	// XXX this essentially rewrites the whole map, is there a faster/better 

package/Promise.js

@@ -117,6 +117,9 @@ object.Constructor('IterablePromise', Promise, {
 				return (e && e.flat) ? 
 					e.flat(depth) 
 					: e }) },
+	// XXX do we need this???
+	//iter: function(){
+	//	return this },
 
 
 	// XXX do we need:

package/README.md

@@ -80,19 +80,23 @@ Library of JavaScript type extensions, types and utilities.
       - [`generator.iter(..)`](#generatoriter)
       - [`generator.STOP`](#generatorstop)
     - [Generator instance iteration](#generator-instance-iteration)
+      - [`<generator>.iter()`](#generatoriter-1)
       - [`<generator>.map(..)` / `<generator>.filter(..)`](#generatormap--generatorfilter)
       - [`<generator>.reduce(..)` / `<generator>.greduce(..)`](#generatorreduce--generatorgreduce)
       - [`<generator>.slice(..)`](#generatorslice)
       - [`<generator>.at(..)` / `<generator>.gat(..)`](#generatorat--generatorgat)
       - [`<generator>.flat(..)`](#generatorflat)
       - [`<generator>.shift()` / `<generator>.pop()` / `<generator>.gshift()` / `<generator>.gpop()`](#generatorshift--generatorpop--generatorgshift--generatorgpop)
+      - [`<generator>.unshift(..)` / `<generator>.push(..)`](#generatorunshift--generatorpush)
       - [`<generator>.promise()`](#generatorpromise)
       - [`<generator>.then(..)` / `<generator>.catch(..)` / `<generator>.finally(..)`](#generatorthen--generatorcatch--generatorfinally)
       - [`<generator>.toArray()`](#generatortoarray)
     - [Treating iterators the same as generators](#treating-iterators-the-same-as-generators)
     - [Generator constructor iteration](#generator-constructor-iteration)
+      - [`<Generator>.iter(..)`](#generatoriter-2)
       - [`<Generator>.at(..)` / `<Generator>.gat(..)`](#generatorat--generatorgat-1)
       - [`<Generator>.shift()` / `<Generator>.pop()` / `<Generator>.gshift()` / `<Generator>.gpop()`](#generatorshift--generatorpop--generatorgshift--generatorgpop-1)
+      - [`<generator>.unshift(..)` / `<generator>.push(..)`](#generatorunshift--generatorpush-1)
       - [`<Generator>.slice(..)`](#generatorslice-1)
       - [`<Generator>.map(..)` / `<Generator>.filter(..)` / `<Generator>.reduce(..)` / `<Generator>.flat()`](#generatormap--generatorfilter--generatorreduce--generatorflat)
       - [`<Generator>.toArray()`](#generatortoarray-1)
@@ -1739,6 +1743,17 @@ Chained generators handle items depth-first, i.e. the items are passed as they
 are yielded down the generator chain.
 
 
+#### `<generator>.iter()`
+
+Iterate over the generator.
+```bnf
+<generator>.iter()
+    -> <generator>
+```
+
+This is here mainly for compatibility with [`<array>`'s `.iter()`](#arrayiter--arrayiter).
+
+
 #### `<generator>.map(..)` / `<generator>.filter(..)` 
 
 Equivalents to `Array`'s `.map(..)`, `.filter(..)` and `.reduce(..)` but return 
@@ -1848,6 +1863,18 @@ Note that `.shift()`/`.gshift()` will yield the item the generator is at at
 time of call, this may not be the _first_ item if the generator is partially 
 depleted.
 
+#### `<generator>.unshift(..)` / `<generator>.push(..)`
+
+Add a value to the generator sequence at start/end.
+```bnf
+<generator>.unshift(<value>)
+<generator>.push(<value>)
+    -> <generator>
+```
+
+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()`
 
@@ -1969,6 +1996,13 @@ XXX list the differences...
 -->
 
 
+#### `<Generator>.iter(..)`
+
+This is a shorthand to [`iter(..)`](#generatoriter).
+
+This is here mainly for compatibility with 
+[`Array`'s `.iter(..)`](#arrayiter--arrayiter).
+
 #### `<Generator>.at(..)` / `<Generator>.gat(..)`
 
 ```bnf
@@ -2002,6 +2036,18 @@ Equivalents to [`<generator>`'s `.shift(..)`/`.pop(..)`/..](#generatorshift--gen
 but returning a reusable `<func>`/`<Generator>`.
 
 
+#### `<generator>.unshift(..)` / `<generator>.push(..)`
+
+```bnf
+<Generator>.unshift(<value>)
+<Generator>.push(<value>)
+    -> <Generator>
+```
+
+Equivalents to [`<generator>`'s `.unshift(..)`/`.push(..)`](#generatorunshift--generatorpush) 
+but returning a reusable `<Generator>`.
+
+
 #### `<Generator>.slice(..)`
 
 ```bnf

package/Set.js

@@ -16,6 +16,10 @@ var object = require('ig-object')
 var SetProtoMixin =
 module.SetProtoMixin =
 object.Mixin('SetMixin', 'soft', {
+	iter: function*(){
+		for(var e of this){
+			yield e } },
+
 	// Set set operation shorthands...
 	unite: function(other=[]){ 
 		return new Set([...this, ...other]) },

package/generator.js

@@ -190,6 +190,10 @@ module.GeneratorMixin =
 object.Mixin('GeneratorMixin', 'soft', {
 	STOP: object.STOP,
 
+	// NOTE: this is here for compatibility with Array.iter(..)
+	iter: function*(lst=[]){
+		yield* module.iter(lst) },
+
 	gat: makeGenerator('gat'),
 	at: function(i){
 		var that = this
@@ -227,6 +231,7 @@ object.Mixin('GeneratorMixin', 'soft', {
 			{ toString: function(){
 				return that.toString() 
 					+ '\n    .gpop()'}, }) },
+	push: makeGenerator('push'),
 	gshift: makeGenerator('gshift'),
 	shift: function(){
 		var that = this
@@ -237,6 +242,7 @@ object.Mixin('GeneratorMixin', 'soft', {
 			{ toString: function(){
 				return that.toString() 
 					+ '\n    .gshift()'}, }) },
+	unshift: makeGenerator('unshift'),
 
 	// promises...
 	//
@@ -263,6 +269,10 @@ object.Mixin('GeneratorMixin', 'soft', {
 var GeneratorProtoMixin =
 module.GeneratorProtoMixin =
 object.Mixin('GeneratorProtoMixin', 'soft', {
+	// NOTE: this is here for compatibility with [..].iter()
+	iter: function*(){ 
+		yield* this },
+
 	at: function(i){
 		return this.gat(i).next().value },
 	// XXX this needs the value to be iterable... why???
@@ -352,11 +362,17 @@ object.Mixin('GeneratorProtoMixin', 'soft', {
 	// XXX this needs the value to be iterable...
 	gpop: function*(){
 		yield [...this].pop() },
+	push: function*(value){
+		yield* this
+		yield value },
 	shift: function(){
 		return this.next().value },
 	// XXX this needs the value to be iterable...
 	gshift: function*(){
 		yield this.next().value },
+	unshift: function*(value){
+		yield value
+		yield* this },
 
 	// non-generators...
 	//

package/package.json

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