@jdeighan/coffee-utils 13.0.12 → 13.0.14

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@jdeighan/coffee-utils",
 	"type": "module",
-	"version": "13.0.12",
+	"version": "13.0.14",
 	"description": "A set of utility functions for CoffeeScript",
 	"main": "coffee_utils.js",
 	"exports": {
@@ -50,13 +50,13 @@
 	},
 	"homepage": "https://github.com/johndeighan/coffee-utils#readme",
 	"dependencies": {
-		"@jdeighan/base-utils": "^2.0.8",
+		"@jdeighan/base-utils": "^2.0.9",
 		"cross-env": "^7.0.3",
 		"n-readlines": "^1.0.1",
 		"readline-sync": "^1.4.10",
 		"svelte": "^3.55.0"
 	},
 	"devDependencies": {
-		"@jdeighan/unit-tester": "^3.0.8"
+		"@jdeighan/unit-tester": "^3.0.9"
 	}
 }

package/src/DataStores.coffee

@@ -13,97 +13,37 @@ import {
 
 # ---------------------------------------------------------------------------
 
-export class WritableDataStore
-
-	constructor: (value=undef) ->
-		@store = writable value
-
-	subscribe: (func) ->
-		return @store.subscribe(func)
-
-	set: (value) ->
-		@store.set(value)
-
-	update: (func) ->
-		@store.update(func)
-
-# ---------------------------------------------------------------------------
-
-export class BaseDataStore
+export class StaticDataStore
 
-	constructor: (@value=undef) ->
-		@lSubscribers = []
+	constructor: (value) ->
+		@value = value
 
-	subscribe: (func) ->
-		func @value
-		@lSubscribers.push func
+	subscribe: (cbFunc) ->
+		cbFunc @value
 		return () ->
-			pos = @lSubscribers.indexOf func
-			@lSubscribers.splice pos, 1
+			pass()
 
 	set: (val) ->
-		@value = val
-		@alertSubscribers()
-		return
+		croak "Can't set() a StaticDataStore"
 
 	update: (func) ->
-		@value = func(@value)
-		@alertSubscribers()
-		return
-
-	alertSubscribers: () ->
-		for func in @lSubscribers
-			func @value
-		return
+		croak "Can't update() a StaticDataStore"
 
 # ---------------------------------------------------------------------------
 
-export class ToDoDataStore
-	# --- implement without using svelte's readable or writable
-
-	constructor: () ->
-		@lToDos = []
-		@lSubscribers = []  # --- array of callback functions
-
-	subscribe: (cbFunc) ->
-		cbFunc(@lToDos)
-		@lSubscribers.push cbFunc
-		return () ->
-			index = @lSubscribers.indexOf cbFunc
-			@lSubscribers.splice index, 1
-
-	alertSubscribers: () ->
-		for cbFunc in @lSubscribers
-			cbFunc(@lToDos)
-		return
+export class WritableDataStore
 
-	find: (name) ->
-		# --- returns index
-		for index in range(@lToDos.length)
-			if (@lToDos[index].text == name)
-				return index
-		return undef
+	constructor: (value=undef) ->
+		@store = writable value
 
-	clear: () ->
-		# --- Set new value
-		@lToDos = []
-		@alertSubscribers()
-		return
+	subscribe: (func) ->
+		return @store.subscribe(func)
 
-	add: (name) ->
-		if defined(@find(name))
-			croak "Attempt to add duplicate #{name} todo"
-		@lToDos.push {
-			text: name
-			done: false
-			}
-		@alertSubscribers()
-		return
+	set: (value) ->
+		@store.set(value)
 
-	remove: (name) ->
-		index = @find(name)
-		@lToDos.splice index, 1
-		return
+	update: (func) ->
+		@store.update(func)
 
 # ---------------------------------------------------------------------------
 
@@ -201,6 +141,79 @@ export class TAMLDataStore extends WritableDataStore
 
 		super fromTAML(str)
 
+# ---------------------------------------------------------------------------
+# --- Mainly for better understanding, I've implemented data stores
+#     without using svelte's readable or writable data stores
+
+export class BaseDataStore
+
+	constructor: (@value=undef) ->
+		@lSubscribers = []
+
+	subscribe: (cbFunc) ->
+		cbFunc @value
+		@lSubscribers.push cbFunc
+		return () ->
+			index = @lSubscribers.indexOf cbFunc
+			@lSubscribers.splice index, 1
+
+	set: (val) ->
+		@value = val
+		return
+
+	update: (func) ->
+		@value = func(@value)
+		@alertSubscribers()
+		return
+
+	alertSubscribers: () ->
+		for cbFunc in @lSubscribers
+			cbFunc @value
+		return
+
+# ---------------------------------------------------------------------------
+
+export class ToDoDataStore extends BaseDataStore
+
+	constructor: () ->
+		lToDos = []   # save local reference to make code easier to grok
+		super lToDos
+		@lToDos = lToDos   # can't do this before calling super
+
+	set: (val) ->
+		croak "Don't use set()"
+
+	update: (func) ->
+		croak "Don't use update()"
+
+	find: (name) ->
+		# --- returns index
+		for index in range(@lToDos.length)
+			if (@lToDos[index].text == name)
+				return index
+		return undef
+
+	clear: () ->
+		# --- Don't set a new array. That would break our reference
+		@lToDos.splice 0, @lToDos.length
+		return
+
+	add: (name) ->
+		if defined(@find(name))
+			croak "Attempt to add duplicate #{name} todo"
+		@lToDos.push {
+			text: name
+			done: false
+			}
+		@alertSubscribers()
+		return
+
+	remove: (name) ->
+		index = @find(name)
+		@lToDos.splice index, 1
+		@alertSubscribers()
+		return
+
 # ---------------------------------------------------------------------------
 #         UTILITIES
 # ---------------------------------------------------------------------------

package/src/DataStores.js

@@ -35,124 +35,44 @@ import {
 } from '@jdeighan/coffee-utils/fs';
 
 // ---------------------------------------------------------------------------
-export var WritableDataStore = class WritableDataStore {
-  constructor(value = undef) {
-    this.store = writable(value);
-  }
-
-  subscribe(func) {
-    return this.store.subscribe(func);
-  }
-
-  set(value) {
-    return this.store.set(value);
+export var StaticDataStore = class StaticDataStore {
+  constructor(value) {
+    this.value = value;
   }
 
-  update(func) {
-    return this.store.update(func);
-  }
-
-};
-
-// ---------------------------------------------------------------------------
-export var BaseDataStore = class BaseDataStore {
-  constructor(value1 = undef) {
-    this.value = value1;
-    this.lSubscribers = [];
-  }
-
-  subscribe(func) {
-    func(this.value);
-    this.lSubscribers.push(func);
+  subscribe(cbFunc) {
+    cbFunc(this.value);
     return function() {
-      var pos;
-      pos = this.lSubscribers.indexOf(func);
-      return this.lSubscribers.splice(pos, 1);
+      return pass();
     };
   }
 
   set(val) {
-    this.value = val;
-    this.alertSubscribers();
+    return croak("Can't set() a StaticDataStore");
   }
 
   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);
-    }
+    return croak("Can't update() a StaticDataStore");
   }
 
 };
 
 // ---------------------------------------------------------------------------
-export var ToDoDataStore = class ToDoDataStore {
-  // --- implement without using svelte's readable or writable
-  constructor() {
-    this.lToDos = [];
-    this.lSubscribers = []; // --- array of callback functions
-  }
-
-  subscribe(cbFunc) {
-    cbFunc(this.lToDos);
-    this.lSubscribers.push(cbFunc);
-    return function() {
-      var index;
-      index = this.lSubscribers.indexOf(cbFunc);
-      return this.lSubscribers.splice(index, 1);
-    };
-  }
-
-  alertSubscribers() {
-    var cbFunc, i, len, ref;
-    ref = this.lSubscribers;
-    for (i = 0, len = ref.length; i < len; i++) {
-      cbFunc = ref[i];
-      cbFunc(this.lToDos);
-    }
-  }
-
-  find(name) {
-    var i, index, len, ref;
-    ref = range(this.lToDos.length);
-    // --- returns index
-    for (i = 0, len = ref.length; i < len; i++) {
-      index = ref[i];
-      if (this.lToDos[index].text === name) {
-        return index;
-      }
-    }
-    return undef;
+export var WritableDataStore = class WritableDataStore {
+  constructor(value = undef) {
+    this.store = writable(value);
   }
 
-  clear() {
-    // --- Set new value
-    this.lToDos = [];
-    this.alertSubscribers();
+  subscribe(func) {
+    return this.store.subscribe(func);
   }
 
-  add(name) {
-    if (defined(this.find(name))) {
-      croak(`Attempt to add duplicate ${name} todo`);
-    }
-    this.lToDos.push({
-      text: name,
-      done: false
-    });
-    this.alertSubscribers();
+  set(value) {
+    return this.store.set(value);
   }
 
-  remove(name) {
-    var index;
-    index = this.find(name);
-    this.lToDos.splice(index, 1);
+  update(func) {
+    return this.store.update(func);
   }
 
 };
@@ -272,6 +192,100 @@ export var TAMLDataStore = class TAMLDataStore extends WritableDataStore {
 
 };
 
+// ---------------------------------------------------------------------------
+// --- Mainly for better understanding, I've implemented data stores
+//     without using svelte's readable or writable data stores
+export var BaseDataStore = class BaseDataStore {
+  constructor(value1 = undef) {
+    this.value = value1;
+    this.lSubscribers = [];
+  }
+
+  subscribe(cbFunc) {
+    cbFunc(this.value);
+    this.lSubscribers.push(cbFunc);
+    return function() {
+      var index;
+      index = this.lSubscribers.indexOf(cbFunc);
+      return this.lSubscribers.splice(index, 1);
+    };
+  }
+
+  set(val) {
+    this.value = val;
+  }
+
+  update(func) {
+    this.value = func(this.value);
+    this.alertSubscribers();
+  }
+
+  alertSubscribers() {
+    var cbFunc, i, len, ref;
+    ref = this.lSubscribers;
+    for (i = 0, len = ref.length; i < len; i++) {
+      cbFunc = ref[i];
+      cbFunc(this.value);
+    }
+  }
+
+};
+
+// ---------------------------------------------------------------------------
+export var ToDoDataStore = class ToDoDataStore extends BaseDataStore {
+  constructor() {
+    var lToDos;
+    lToDos = []; // save local reference to make code easier to grok
+    super(lToDos);
+    this.lToDos = lToDos; // can't do this before calling super
+  }
+
+  set(val) {
+    return croak("Don't use set()");
+  }
+
+  update(func) {
+    return croak("Don't use update()");
+  }
+
+  find(name) {
+    var i, index, len, ref;
+    ref = range(this.lToDos.length);
+    // --- returns index
+    for (i = 0, len = ref.length; i < len; i++) {
+      index = ref[i];
+      if (this.lToDos[index].text === name) {
+        return index;
+      }
+    }
+    return undef;
+  }
+
+  clear() {
+    // --- Don't set a new array. That would break our reference
+    this.lToDos.splice(0, this.lToDos.length);
+  }
+
+  add(name) {
+    if (defined(this.find(name))) {
+      croak(`Attempt to add duplicate ${name} todo`);
+    }
+    this.lToDos.push({
+      text: name,
+      done: false
+    });
+    this.alertSubscribers();
+  }
+
+  remove(name) {
+    var index;
+    index = this.find(name);
+    this.lToDos.splice(index, 1);
+    this.alertSubscribers();
+  }
+
+};
+
 // ---------------------------------------------------------------------------
 //         UTILITIES
 // ---------------------------------------------------------------------------