@jdeighan/coffee-utils 12.0.1 → 13.0.0

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@jdeighan/coffee-utils",
 	"type": "module",
-	"version": "12.0.1",
+	"version": "13.0.0",
 	"description": "A set of utility functions for CoffeeScript",
 	"main": "coffee_utils.js",
 	"exports": {
@@ -22,6 +22,8 @@
 		"./section": "./src/Section.js",
 		"./sectionmap": "./src/SectionMap.js",
 		"./fsa": "./src/fsa.js",
+		"./giftset": "./src/GiftSet.js",
+		"./keyedset": "./src/KeyedSet.js",
 		"./package.json": "./package.json"
 	},
 	"engines": {
@@ -48,14 +50,15 @@
 	},
 	"homepage": "https://github.com/johndeighan/coffee-utils#readme",
 	"dependencies": {
-		"@jdeighan/base-utils": "^1.0.10",
+		"@jdeighan/base-utils": "^2.0.0",
 		"cross-env": "^7.0.3",
+		"immer": "^9.0.16",
 		"js-yaml": "^4.1.0",
 		"n-readlines": "^1.0.1",
 		"readline-sync": "^1.4.10",
-		"svelte": "^3.53.1"
+		"svelte": "^3.54.0"
 	},
 	"devDependencies": {
-		"@jdeighan/unit-tester": "^2.0.69"
+		"@jdeighan/unit-tester": "^3.0.0"
 	}
 }

package/src/DataStores.coffee

@@ -10,6 +10,7 @@ import {
 	withExt, slurp, barf, newerDestFileExists,
 	} from '@jdeighan/coffee-utils/fs'
 import {fromTAML} from '@jdeighan/coffee-utils/taml'
+import {createDraft, finishDraft, produce} from 'immer'
 
 # ---------------------------------------------------------------------------
 
@@ -18,8 +19,8 @@ export class WritableDataStore
 	constructor: (value=undef) ->
 		@store = writable value
 
-	subscribe: (callback) ->
-		return @store.subscribe(callback)
+	subscribe: (func) ->
+		return @store.subscribe(func)
 
 	set: (value) ->
 		@store.set(value)
@@ -29,6 +30,91 @@ export class WritableDataStore
 
 # ---------------------------------------------------------------------------
 
+export class BaseDataStore
+
+	constructor: (@value=undef) ->
+		@lSubscribers = []
+
+	subscribe: (func) ->
+		func @value
+		@lSubscribers.push func
+		return () ->
+			pos = @lSubscribers.indexOf func
+			@lSubscribers.splice pos, 1
+
+	set: (val) ->
+		@value = val
+		@alertSubscribers()
+		return
+
+	update: (func) ->
+		@value = func(@value)
+		@alertSubscribers()
+		return
+
+	alertSubscribers: () ->
+		for func in @lSubscribers
+			func @value
+		return
+
+# ---------------------------------------------------------------------------
+
+export class ImmerDataStore extends BaseDataStore
+
+	constructor: () ->
+		super []    # initialize with an empty array
+
+	getNewState: () ->
+
+		return produce state, draft =>
+			@addGift draft, description, image
+		return
+
+	addGift: (draft, description, image) ->
+		draft.push {
+			id: 1
+			description
+			image
+			}
+
+# ---------------------------------------------------------------------------
+
+export class ToDoDataStore
+	# --- implemented with immer
+
+	constructor: () ->
+		@lToDos = []
+		@lSubscribers = []
+
+	subscribe: (func) ->
+		func(@lToDos)
+		@lSubscribers.push func
+		return () ->
+			index = @lSubscribers.indexOf func
+			@lSubscribers.splice index, 1
+
+	alertSubscribers: () ->
+		for func in @lSubscribers
+			func(@lToDos)
+		return
+
+	set: (value) ->
+		# --- Set new value
+		@alertSubscribers()
+
+	update: (func) ->
+		# --- Update value
+		@alertSubscribers()
+
+	add: (name) ->
+		@lToDos.push {
+			text: name
+			done: false
+			}
+		return
+
+# ---------------------------------------------------------------------------
+
 export class LocalStorageDataStore extends WritableDataStore
 
 	constructor: (@masterKey, defValue=undef) ->

package/src/DataStores.js

@@ -33,14 +33,20 @@ import {
   fromTAML
 } from '@jdeighan/coffee-utils/taml';
 
+import {
+  createDraft,
+  finishDraft,
+  produce
+} from 'immer';
+
 // ---------------------------------------------------------------------------
 export var WritableDataStore = class WritableDataStore {
   constructor(value = undef) {
     this.store = writable(value);
   }
 
-  subscribe(callback) {
-    return this.store.subscribe(callback);
+  subscribe(func) {
+    return this.store.subscribe(func);
   }
 
   set(value) {
@@ -53,6 +59,112 @@ export var WritableDataStore = class WritableDataStore {
 
 };
 
+// ---------------------------------------------------------------------------
+export var BaseDataStore = class BaseDataStore {
+  constructor(value1 = undef) {
+    this.value = value1;
+    this.lSubscribers = [];
+  }
+
+  subscribe(func) {
+    func(this.value);
+    this.lSubscribers.push(func);
+    return function() {
+      var pos;
+      pos = this.lSubscribers.indexOf(func);
+      return this.lSubscribers.splice(pos, 1);
+    };
+  }
+
+  set(val) {
+    this.value = val;
+    this.alertSubscribers();
+  }
+
+  update(func) {
+    this.value = func(this.value);
+    this.alertSubscribers();
+  }
+
+  alertSubscribers() {
+    var func, i, len, ref;
+    ref = this.lSubscribers;
+    for (i = 0, len = ref.length; i < len; i++) {
+      func = ref[i];
+      func(this.value);
+    }
+  }
+
+};
+
+// ---------------------------------------------------------------------------
+export var ImmerDataStore = class ImmerDataStore extends BaseDataStore {
+  constructor() {
+    super([]); // initialize with an empty array
+  }
+
+  getNewState() {
+    return produce(state, draft(() => {
+      return this.addGift(draft, description, image);
+    }));
+  }
+
+  addGift(draft, description, image) {
+    return draft.push({
+      id: 1,
+      description,
+      image
+    });
+  }
+
+};
+
+// ---------------------------------------------------------------------------
+export var ToDoDataStore = class ToDoDataStore {
+  // --- implemented with immer
+  constructor() {
+    this.lToDos = [];
+    this.lSubscribers = [];
+  }
+
+  subscribe(func) {
+    func(this.lToDos);
+    this.lSubscribers.push(func);
+    return function() {
+      var index;
+      index = this.lSubscribers.indexOf(func);
+      return this.lSubscribers.splice(index, 1);
+    };
+  }
+
+  alertSubscribers() {
+    var func, i, len, ref;
+    ref = this.lSubscribers;
+    for (i = 0, len = ref.length; i < len; i++) {
+      func = ref[i];
+      func(this.lToDos);
+    }
+  }
+
+  set(value) {
+    // --- Set new value
+    return this.alertSubscribers();
+  }
+
+  update(func) {
+    // --- Update value
+    return this.alertSubscribers();
+  }
+
+  add(name) {
+    this.lToDos.push({
+      text: name,
+      done: false
+    });
+  }
+
+};
+
 // ---------------------------------------------------------------------------
 export var LocalStorageDataStore = class LocalStorageDataStore extends WritableDataStore {
   constructor(masterKey1, defValue = undef) {

package/src/GiftSet.coffee

@@ -0,0 +1,61 @@
+# GiftSet.coffee
+
+import {produce, enableMapSet} from 'immer'
+import {assert, croak, LOG, LOGVALUE} from '@jdeighan/base-utils'
+import {
+	dbgEnter, dbgReturn, dbg,
+	} from '@jdeighan/base-utils/debug'
+import {
+	undef, defined, notdefined, OL,
+	isString, isNonEmptyString, isArray, isHash, isArrayOfStrings,
+	isEmpty, nonEmpty,
+	} from '@jdeighan/coffee-utils'
+
+enableMapSet()
+
+# ---------------------------------------------------------------------------
+
+export LOGMAP = (label, map) ->
+
+	lLines = ["MAP #{label}:"]
+	for [key, value] from map.entries()
+		lLines.push "   #{OL(key)}: #{OL(value)}"
+	LOG lLines.join("\n")
+	LOG()
+	return
+
+# ---------------------------------------------------------------------------
+
+export addGift = produce (draft, giftName, hData={}) ->
+
+	assert (draft instanceof Map), "draft is not a Map"
+	if draft.get giftName
+		throw new Error("Gift #{giftName} already exists")
+	hValue = {hData...}
+	hValue.name = giftName
+	draft.set giftName, hValue
+	return
+
+# ---------------------------------------------------------------------------
+
+export reserveGift = produce (draft, giftName, user) ->
+
+	assert (draft instanceof Map), "draft is not a Map"
+	gift = draft.get giftName
+	assert gift?, "No such gift: #{giftName}"
+	gift.reservedBy = user
+	return
+
+# ---------------------------------------------------------------------------
+
+export cancelReservation = produce (draft, giftName) ->
+
+	assert (draft instanceof Map), "draft is not a Map"
+	gift = draft.get giftName
+	assert defined(gift), "No such gift: #{giftName}"
+	delete gift.reservedBy
+	return
+
+# ---------------------------------------------------------------------------
+
+

package/src/GiftSet.js

@@ -0,0 +1,80 @@
+// Generated by CoffeeScript 2.7.0
+  // GiftSet.coffee
+import {
+  produce,
+  enableMapSet
+} from 'immer';
+
+import {
+  assert,
+  croak,
+  LOG,
+  LOGVALUE
+} from '@jdeighan/base-utils';
+
+import {
+  dbgEnter,
+  dbgReturn,
+  dbg
+} from '@jdeighan/base-utils/debug';
+
+import {
+  undef,
+  defined,
+  notdefined,
+  OL,
+  isString,
+  isNonEmptyString,
+  isArray,
+  isHash,
+  isArrayOfStrings,
+  isEmpty,
+  nonEmpty
+} from '@jdeighan/coffee-utils';
+
+enableMapSet();
+
+// ---------------------------------------------------------------------------
+export var LOGMAP = function(label, map) {
+  var key, lLines, ref, value, x;
+  lLines = [`MAP ${label}:`];
+  ref = map.entries();
+  for (x of ref) {
+    [key, value] = x;
+    lLines.push(`   ${OL(key)}: ${OL(value)}`);
+  }
+  LOG(lLines.join("\n"));
+  LOG();
+};
+
+// ---------------------------------------------------------------------------
+export var addGift = produce(function(draft, giftName, hData = {}) {
+  var hValue;
+  assert(draft instanceof Map, "draft is not a Map");
+  if (draft.get(giftName)) {
+    throw new Error(`Gift ${giftName} already exists`);
+  }
+  hValue = {...hData};
+  hValue.name = giftName;
+  draft.set(giftName, hValue);
+});
+
+// ---------------------------------------------------------------------------
+export var reserveGift = produce(function(draft, giftName, user) {
+  var gift;
+  assert(draft instanceof Map, "draft is not a Map");
+  gift = draft.get(giftName);
+  assert(gift != null, `No such gift: ${giftName}`);
+  gift.reservedBy = user;
+});
+
+// ---------------------------------------------------------------------------
+export var cancelReservation = produce(function(draft, giftName) {
+  var gift;
+  assert(draft instanceof Map, "draft is not a Map");
+  gift = draft.get(giftName);
+  assert(defined(gift), `No such gift: ${giftName}`);
+  delete gift.reservedBy;
+});
+
+// ---------------------------------------------------------------------------

package/src/KeyedSet.coffee

@@ -0,0 +1,153 @@
+# KeyedSet.coffee
+
+import {assert, croak, LOG, LOGVALUE} from '@jdeighan/base-utils'
+import {
+	dbgEnter, dbgReturn, dbg,
+	} from '@jdeighan/base-utils/debug'
+import {
+	undef, defined, notdefined, OL, deepCopy,
+	isString, isNonEmptyString, isArray, isHash, isArrayOfStrings,
+	isEmpty, nonEmpty,
+	} from '@jdeighan/coffee-utils'
+
+# ---------------------------------------------------------------------------
+
+export class KeyedSet extends Map
+
+	constructor: (@setName, lKeyNames, @sep='|') ->
+		# --- lKeyNames can be:
+		#        1. a non-empty string
+		#        2. an array of non-empty strings
+
+		dbgEnter 'KeyedSet'
+		super()
+		assert isNonEmptyString(@setName), "bad set name: #{OL(@setName)}"
+		if isString(lKeyNames)
+			assert nonEmpty(lKeyNames), "empty string key name"
+			@lKeyNames = [lKeyNames]
+			@numKeys = 1
+		else if isArray(lKeyNames)
+			assert nonEmpty(lKeyNames), "empty key name array"
+			for name in lKeyNames
+				assert isNonEmptyString(name),
+						"name not a non-empty string: #{OL(name)}"
+			@numKeys = lKeyNames.length
+			@lKeyNames = lKeyNames
+		else
+			croak "Invalid key names: #{OL(lKeyNames)}"
+		dbg "key is #{OL(@lKeyNames)}"
+		dbgReturn 'KeyedSet'
+
+	# ..........................................................
+
+	add: (keyVal, hData={}) ->
+
+		dbgEnter 'add', keyVal, hData
+		assert ! @has(keyVal), "adding duplicate key #{OL(keyVal)}"
+		assert isHash(hData), "hData not a hash: #{OL(hData)}"
+		dbg "not a duplicate"
+
+		hItem = deepCopy hData
+
+		# --- Add key values to hItem
+		lKeyVals = @getKeyValues keyVal
+		for name,i in @lKeyNames
+			assert notdefined(hItem[name]),
+					"hData has key #{name}"
+			hItem[name] = lKeyVals[i]
+
+		key = @getKey(keyVal)
+		dbg 'key', key
+		dbg 'value', hItem
+		@set key, hItem    # set() is a method in Map, the base class
+		@length = @size    # add to all methods that change size
+		dbgReturn 'add'
+		return this   # allow chaining
+
+	# ..........................................................
+
+	getKey: (keyVal) ->
+		# --- Get the actual key used in the underlying Map object
+
+		dbgEnter 'getKey'
+		key = @getKeyValues(keyVal).join(@sep)
+		dbgReturn 'getKey', key
+		return key
+
+	# ..........................................................
+
+	getKeyValues: (keyVal) ->
+		# --- Accepts either a string or an array of strings
+		#     But all keys must be non-empty strings
+		#     Always returns an array
+
+		dbgEnter 'getKeyValues', keyVal
+		if isString(keyVal)
+			lKeyVals = [keyVal]
+		else if isArray(keyVal)
+			lKeyVals = keyVal
+		else
+			croak "Bad key value: #{OL(keyVal)}"
+		assert (lKeyVals.length == @numKeys), "Bad # keys in #{OL(keyVal)}"
+		for val in lKeyVals
+			assert isNonEmptyString(val), "Bad key val: #{OL(val)}"
+		dbgReturn 'getKeyValues', lKeyVals
+		return lKeyVals
+
+	# ..........................................................
+
+	has: (keyVal) ->
+
+		return super @getKey(keyVal)
+
+	# ..........................................................
+
+	update: (keyVal, hData={}) ->
+
+		dbgEnter 'update', keyVal, hData
+		key = @getKey(keyVal)
+		dbg "key = #{OL(key)}"
+		hItem = @get(key)
+		dbg 'hItem', hItem
+		assert defined(hItem), "updating missing key #{OL(keyVal)}"
+		for key,val of hData
+			hItem[key] = val
+		dbgReturn 'update'
+		return this   # allow chaining
+
+	# ..........................................................
+
+	remove: (keyVal) ->
+
+		key = @getKey(keyVal)
+		if ! @delete key
+			croak "No key #{OL(keyVal)} in #{@setName}"
+		@length = @size    # add to all methods that change size
+		return this   # allow chaining
+
+	# ..........................................................
+
+	getAllItems: () ->
+		# --- Useful for unit tests, but it's usually better
+		#     to use a generator like .entries()
+
+		return Array.from(@values())
+
+	# ..........................................................
+
+	get: (keyVal) ->
+		# --- Override to require that it exists
+
+		item = super @getKey(keyVal)
+		assert defined(item), "No such item: #{OL(keyVal)} in #{@setName}"
+		return item
+
+	# ..........................................................
+
+	dump: () ->
+
+		console.log "DUMP #{@setName}:"
+		for [key, value] from @entries()
+			console.log "#{OL(key)}: #{OL(value)}"
+
+# ---------------------------------------------------------------------------

package/src/KeyedSet.js

@@ -0,0 +1,187 @@
+// Generated by CoffeeScript 2.7.0
+  // KeyedSet.coffee
+import {
+  assert,
+  croak,
+  LOG,
+  LOGVALUE
+} from '@jdeighan/base-utils';
+
+import {
+  dbgEnter,
+  dbgReturn,
+  dbg
+} from '@jdeighan/base-utils/debug';
+
+import {
+  undef,
+  defined,
+  notdefined,
+  OL,
+  deepCopy,
+  isString,
+  isNonEmptyString,
+  isArray,
+  isHash,
+  isArrayOfStrings,
+  isEmpty,
+  nonEmpty
+} from '@jdeighan/coffee-utils';
+
+// ---------------------------------------------------------------------------
+export var KeyedSet = class KeyedSet extends Map {
+  constructor(setName, lKeyNames, sep = '|') {
+    var j, len, name;
+    // --- lKeyNames can be:
+    //        1. a non-empty string
+    //        2. an array of non-empty strings
+    dbgEnter('KeyedSet');
+    super();
+    this.setName = setName;
+    this.sep = sep;
+    assert(isNonEmptyString(this.setName), `bad set name: ${OL(this.setName)}`);
+    if (isString(lKeyNames)) {
+      assert(nonEmpty(lKeyNames), "empty string key name");
+      this.lKeyNames = [lKeyNames];
+      this.numKeys = 1;
+    } else if (isArray(lKeyNames)) {
+      assert(nonEmpty(lKeyNames), "empty key name array");
+      for (j = 0, len = lKeyNames.length; j < len; j++) {
+        name = lKeyNames[j];
+        assert(isNonEmptyString(name), `name not a non-empty string: ${OL(name)}`);
+      }
+      this.numKeys = lKeyNames.length;
+      this.lKeyNames = lKeyNames;
+    } else {
+      croak(`Invalid key names: ${OL(lKeyNames)}`);
+    }
+    dbg(`key is ${OL(this.lKeyNames)}`);
+    dbgReturn('KeyedSet');
+  }
+
+  // ..........................................................
+  add(keyVal, hData = {}) {
+    var hItem, i, j, key, lKeyVals, len, name, ref;
+    dbgEnter('add', keyVal, hData);
+    assert(!this.has(keyVal), `adding duplicate key ${OL(keyVal)}`);
+    assert(isHash(hData), `hData not a hash: ${OL(hData)}`);
+    dbg("not a duplicate");
+    hItem = deepCopy(hData);
+    // --- Add key values to hItem
+    lKeyVals = this.getKeyValues(keyVal);
+    ref = this.lKeyNames;
+    for (i = j = 0, len = ref.length; j < len; i = ++j) {
+      name = ref[i];
+      assert(notdefined(hItem[name]), `hData has key ${name}`);
+      hItem[name] = lKeyVals[i];
+    }
+    key = this.getKey(keyVal);
+    dbg('key', key);
+    dbg('value', hItem);
+    this.set(key, hItem); // set() is a method in Map, the base class
+    this.length = this.size; // add to all methods that change size
+    dbgReturn('add');
+    return this; // allow chaining
+  }
+
+  
+    // ..........................................................
+  getKey(keyVal) {
+    var key;
+    // --- Get the actual key used in the underlying Map object
+    dbgEnter('getKey');
+    key = this.getKeyValues(keyVal).join(this.sep);
+    dbgReturn('getKey', key);
+    return key;
+  }
+
+  // ..........................................................
+  getKeyValues(keyVal) {
+    var j, lKeyVals, len, val;
+    // --- Accepts either a string or an array of strings
+    //     But all keys must be non-empty strings
+    //     Always returns an array
+    dbgEnter('getKeyValues', keyVal);
+    if (isString(keyVal)) {
+      lKeyVals = [keyVal];
+    } else if (isArray(keyVal)) {
+      lKeyVals = keyVal;
+    } else {
+      croak(`Bad key value: ${OL(keyVal)}`);
+    }
+    assert(lKeyVals.length === this.numKeys, `Bad # keys in ${OL(keyVal)}`);
+    for (j = 0, len = lKeyVals.length; j < len; j++) {
+      val = lKeyVals[j];
+      assert(isNonEmptyString(val), `Bad key val: ${OL(val)}`);
+    }
+    dbgReturn('getKeyValues', lKeyVals);
+    return lKeyVals;
+  }
+
+  // ..........................................................
+  has(keyVal) {
+    return super.has(this.getKey(keyVal));
+  }
+
+  // ..........................................................
+  update(keyVal, hData = {}) {
+    var hItem, key, val;
+    dbgEnter('update', keyVal, hData);
+    key = this.getKey(keyVal);
+    dbg(`key = ${OL(key)}`);
+    hItem = this.get(key);
+    dbg('hItem', hItem);
+    assert(defined(hItem), `updating missing key ${OL(keyVal)}`);
+    for (key in hData) {
+      val = hData[key];
+      hItem[key] = val;
+    }
+    dbgReturn('update');
+    return this; // allow chaining
+  }
+
+  
+    // ..........................................................
+  remove(keyVal) {
+    var key;
+    key = this.getKey(keyVal);
+    if (!this.delete(key)) {
+      croak(`No key ${OL(keyVal)} in ${this.setName}`);
+    }
+    this.length = this.size; // add to all methods that change size
+    return this; // allow chaining
+  }
+
+  
+    // ..........................................................
+  getAllItems() {
+    // --- Useful for unit tests, but it's usually better
+    //     to use a generator like .entries()
+    return Array.from(this.values());
+  }
+
+  // ..........................................................
+  get(keyVal) {
+    var item;
+    // --- Override to require that it exists
+    item = super.get(this.getKey(keyVal));
+    assert(defined(item), `No such item: ${OL(keyVal)} in ${this.setName}`);
+    return item;
+  }
+
+  // ..........................................................
+  dump() {
+    var key, ref, results, value, x;
+    console.log(`DUMP ${this.setName}:`);
+    ref = this.entries();
+    results = [];
+    for (x of ref) {
+      [key, value] = x;
+      results.push(console.log(`${OL(key)}: ${OL(value)}`));
+    }
+    return results;
+  }
+
+};
+
+// ---------------------------------------------------------------------------