@jdeighan/coffee-utils 14.0.28 → 14.0.30

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@jdeighan/coffee-utils",
 	"type": "module",
-	"version": "14.0.28",
+	"version": "14.0.30",
 	"description": "A set of utility functions for CoffeeScript",
 	"main": "coffee_utils.js",
 	"exports": {
@@ -13,10 +13,6 @@
 		"./indent": "./src/indent.js",
 		"./html": "./src/html.js",
 		"./stack": "./src/stack.js",
-		"./debug": "./src/debug.js",
-		"./arrow": "./src/arrow.js",
-		"./svelte": "./src/svelte.js",
-		"./store": "./src/DataStores.js",
 		"./taml": "./src/taml.js",
 		"./section": "./src/Section.js",
 		"./sectionmap": "./src/SectionMap.js",
@@ -49,13 +45,13 @@
 	},
 	"homepage": "https://github.com/johndeighan/coffee-utils#readme",
 	"dependencies": {
-		"@jdeighan/base-utils": "^4.0.13",
+		"@jdeighan/base-utils": "^4.0.15",
 		"cross-env": "^7.0.3",
 		"n-readlines": "^1.0.1",
 		"readline-sync": "^1.4.10",
 		"svelte": "^3.55.1"
 	},
 	"devDependencies": {
-		"@jdeighan/unit-tester": "^3.0.38"
+		"@jdeighan/unit-tester": "^3.0.39"
 	}
 }

package/src/DataStores.coffee

@@ -1,257 +0,0 @@
-# DataStores.coffee
-
-import pathlib from 'path'
-import {writable, readable, get} from 'svelte/store'
-
-import {
-	undef, defined, notdefined, pass, range, getOptions,
-	} from '@jdeighan/base-utils'
-import {assert, croak} from '@jdeighan/base-utils/exceptions'
-import {fromTAML} from '@jdeighan/base-utils/taml'
-import {localStore} from '@jdeighan/coffee-utils/browser'
-import {
-	withExt, slurp, barf, newerDestFileExists,
-	} from '@jdeighan/coffee-utils/fs'
-
-# ---------------------------------------------------------------------------
-
-export class StaticDataStore
-
-	constructor: (value) ->
-		@value = value
-
-	subscribe: (cbFunc) ->
-		cbFunc @value
-		return () ->
-			pass()
-
-	set: (val) ->
-		croak "Can't set() a StaticDataStore"
-
-	update: (func) ->
-		croak "Can't update() a StaticDataStore"
-
-# ---------------------------------------------------------------------------
-
-export class WritableDataStore
-
-	constructor: (value=undef) ->
-		@store = writable value
-
-	subscribe: (func) ->
-		return @store.subscribe(func)
-
-	set: (value) ->
-		@store.set(value)
-		return
-
-	update: (func) ->
-		@store.update(func)
-		return
-
-# ---------------------------------------------------------------------------
-
-export class LocalStorageDataStore extends WritableDataStore
-
-	constructor: (@masterKey, defValue=undef) ->
-
-		# --- CoffeeScript forces us to call super first
-		#     so we can't get the localStorage value first
-		super defValue
-		value = localStore(@masterKey)
-		if defined(value)
-			@set value
-
-	# --- I'm assuming that when update() is called,
-	#     set() will also be called
-
-	set: (value) ->
-		assert defined(value), "set(): cannot set to undef"
-		super value
-		localStore @masterKey, value
-		return
-
-	update: (func) ->
-		super func
-		localStore @masterKey, get(@store)
-		return
-
-# ---------------------------------------------------------------------------
-
-export class PropsDataStore extends LocalStorageDataStore
-
-	constructor: (masterKey) ->
-		super masterKey, {}
-
-	setProp: (name, value) ->
-
-		assert defined(name), "PropStore.setProp(): empty key"
-		@update (hPrefs) ->
-			hPrefs[name] = value
-			return hPrefs
-		return
-
-# ---------------------------------------------------------------------------
-
-export class ReadableDataStore
-
-	constructor: () ->
-		@store = readable null, (set) ->
-			@setter = set        # store the setter function
-			@start()             # call your start() method
-			return () => @stop() # return function capable of stopping
-
-	subscribe: (callback) ->
-		return @store.subscribe(callback)
-
-	start: () ->
-		return
-
-	stop: () ->
-		return
-
-# ---------------------------------------------------------------------------
-
-export class DateTimeDataStore extends ReadableDataStore
-
-	start: () ->
-		# --- We need to store this interval for use in stop() later
-		@interval = setInterval(() ->
-			@setter new Date()
-			, 1000)
-		return
-
-	stop: () ->
-		clearInterval @interval
-		return
-
-# ---------------------------------------------------------------------------
-
-export class MousePosDataStore extends ReadableDataStore
-
-	start: () ->
-		# --- We need to store this handler for use in stop() later
-		@mouseMoveHandler = (e) ->
-			@setter {
-				x: e.clientX,
-				y: e.clientY,
-				}
-		document.body.addEventListener('mousemove', @mouseMoveHandler)
-		return
-
-	stop: () ->
-		document.body.removeEventListener('mousemove', @mouseMoveHandler)
-		return
-
-# ---------------------------------------------------------------------------
-
-export class TAMLDataStore extends WritableDataStore
-
-	constructor: (str) ->
-
-		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) ->
-		assert notdefined(@find(name)), "Todo #{name} already exists"
-		@lToDos.push {
-			text: name
-			done: false
-			}
-		@alertSubscribers()
-		return
-
-	remove: (name) ->
-		index = @find(name)
-		@lToDos.splice index, 1
-		@alertSubscribers()
-		return
-
-# ---------------------------------------------------------------------------
-#         UTILITIES
-# ---------------------------------------------------------------------------
-
-export brewTamlStr = (code, stub) =>
-
-	return """
-			import {TAMLDataStore} from '@jdeighan/starbucks/stores';
-
-			export let #{stub} = new TAMLDataStore(`#{code}`);
-			"""
-
-# ---------------------------------------------------------------------------
-
-export brewTamlFile = (srcPath, destPath=undef, hOptions={}) =>
-	# --- taml => js
-	#     Valid Options:
-	#        force
-
-	if notdefined(destPath)
-		destPath = withExt(srcPath, '.js')
-	{force} = getOptions(hOptions)
-	if force || ! newerDestFileExists(srcPath, destPath)
-		hInfo = pathlib.parse(destPath)
-		stub = hInfo.name
-
-		tamlCode = slurp(srcPath)
-		jsCode = brewTamlStr(tamlCode, stub)
-		barf destPath, jsCode
-	return
-
-# ---------------------------------------------------------------------------

package/src/DataStores.js

@@ -1,310 +0,0 @@
-// Generated by CoffeeScript 2.7.0
-// DataStores.coffee
-import pathlib from 'path';
-
-import {
-  writable,
-  readable,
-  get
-} from 'svelte/store';
-
-import {
-  undef,
-  defined,
-  notdefined,
-  pass,
-  range,
-  getOptions
-} from '@jdeighan/base-utils';
-
-import {
-  assert,
-  croak
-} from '@jdeighan/base-utils/exceptions';
-
-import {
-  fromTAML
-} from '@jdeighan/base-utils/taml';
-
-import {
-  localStore
-} from '@jdeighan/coffee-utils/browser';
-
-import {
-  withExt,
-  slurp,
-  barf,
-  newerDestFileExists
-} from '@jdeighan/coffee-utils/fs';
-
-// ---------------------------------------------------------------------------
-export var StaticDataStore = class StaticDataStore {
-  constructor(value) {
-    this.value = value;
-  }
-
-  subscribe(cbFunc) {
-    cbFunc(this.value);
-    return function() {
-      return pass();
-    };
-  }
-
-  set(val) {
-    return croak("Can't set() a StaticDataStore");
-  }
-
-  update(func) {
-    return croak("Can't update() a StaticDataStore");
-  }
-
-};
-
-// ---------------------------------------------------------------------------
-export var WritableDataStore = class WritableDataStore {
-  constructor(value = undef) {
-    this.store = writable(value);
-  }
-
-  subscribe(func) {
-    return this.store.subscribe(func);
-  }
-
-  set(value) {
-    this.store.set(value);
-  }
-
-  update(func) {
-    this.store.update(func);
-  }
-
-};
-
-// ---------------------------------------------------------------------------
-export var LocalStorageDataStore = class LocalStorageDataStore extends WritableDataStore {
-  constructor(masterKey1, defValue = undef) {
-    var value;
-    super(defValue);
-    this.masterKey = masterKey1;
-    value = localStore(this.masterKey);
-    if (defined(value)) {
-      this.set(value);
-    }
-  }
-
-  // --- I'm assuming that when update() is called,
-  //     set() will also be called
-  set(value) {
-    assert(defined(value), "set(): cannot set to undef");
-    super.set(value);
-    localStore(this.masterKey, value);
-  }
-
-  update(func) {
-    super.update(func);
-    localStore(this.masterKey, get(this.store));
-  }
-
-};
-
-// ---------------------------------------------------------------------------
-export var PropsDataStore = class PropsDataStore extends LocalStorageDataStore {
-  constructor(masterKey) {
-    super(masterKey, {});
-  }
-
-  setProp(name, value) {
-    assert(defined(name), "PropStore.setProp(): empty key");
-    this.update(function(hPrefs) {
-      hPrefs[name] = value;
-      return hPrefs;
-    });
-  }
-
-};
-
-// ---------------------------------------------------------------------------
-export var ReadableDataStore = class ReadableDataStore {
-  constructor() {
-    this.store = readable(null, function(set) {
-      this.setter = set; // store the setter function
-      this.start(); // call your start() method
-      return () => {
-        return this.stop(); // return function capable of stopping
-      };
-    });
-  }
-
-  subscribe(callback) {
-    return this.store.subscribe(callback);
-  }
-
-  start() {}
-
-  stop() {}
-
-};
-
-// ---------------------------------------------------------------------------
-export var DateTimeDataStore = class DateTimeDataStore extends ReadableDataStore {
-  start() {
-    // --- We need to store this interval for use in stop() later
-    this.interval = setInterval(function() {
-      return this.setter(new Date(), 1000);
-    });
-  }
-
-  stop() {
-    clearInterval(this.interval);
-  }
-
-};
-
-// ---------------------------------------------------------------------------
-export var MousePosDataStore = class MousePosDataStore extends ReadableDataStore {
-  start() {
-    // --- We need to store this handler for use in stop() later
-    this.mouseMoveHandler = function(e) {
-      return this.setter({
-        x: e.clientX,
-        y: e.clientY
-      });
-    };
-    document.body.addEventListener('mousemove', this.mouseMoveHandler);
-  }
-
-  stop() {
-    document.body.removeEventListener('mousemove', this.mouseMoveHandler);
-  }
-
-};
-
-// ---------------------------------------------------------------------------
-export var TAMLDataStore = class TAMLDataStore extends WritableDataStore {
-  constructor(str) {
-    super(fromTAML(str));
-  }
-
-};
-
-// ---------------------------------------------------------------------------
-// --- 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) {
-    assert(notdefined(this.find(name)), `Todo ${name} already exists`);
-    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
-// ---------------------------------------------------------------------------
-export var brewTamlStr = (code, stub) => {
-  return `import {TAMLDataStore} from '@jdeighan/starbucks/stores';
-
-export let ${stub} = new TAMLDataStore(\`${code}\`);`;
-};
-
-// ---------------------------------------------------------------------------
-export var brewTamlFile = (srcPath, destPath = undef, hOptions = {}) => {
-  var force, hInfo, jsCode, stub, tamlCode;
-  // --- taml => js
-  //     Valid Options:
-  //        force
-  if (notdefined(destPath)) {
-    destPath = withExt(srcPath, '.js');
-  }
-  ({force} = getOptions(hOptions));
-  if (force || !newerDestFileExists(srcPath, destPath)) {
-    hInfo = pathlib.parse(destPath);
-    stub = hInfo.name;
-    tamlCode = slurp(srcPath);
-    jsCode = brewTamlStr(tamlCode, stub);
-    barf(destPath, jsCode);
-  }
-};
-
-// ---------------------------------------------------------------------------

package/src/svelte.coffee

@@ -1,42 +0,0 @@
-# svelte.coffee
-
-import {assert, croak} from '@jdeighan/base-utils/exceptions'
-import {LOG} from '@jdeighan/base-utils/log'
-import {isFunction} from '@jdeighan/base-utils'
-
-# ---------------------------------------------------------------------------
-#   svelteSourceCodeEsc - to display source code for a *.starbucks page
-
-export svelteSourceCodeEsc = (str) =>
-
-	return str \
-		.replace(/\</g, '&lt;') \
-		.replace(/\>/g, '&gt;') \
-		.replace(/\{/g, '&lbrace;') \
-		.replace(/\}/g, '&rbrace;') \
-		.replace(/\$/g, '&dollar;')
-
-# ---------------------------------------------------------------------------
-#   svelteHtmlEsc - after converting markdown
-
-export svelteHtmlEsc = (str) =>
-
-	return str \
-		.replace(/\{/g, '&lbrace;') \
-		.replace(/\}/g, '&rbrace;') \
-		.replace(/\$/g, '&dollar;')
-
-# ---------------------------------------------------------------------------
-
-export onInterval = (func, secs, doLog=false) =>
-
-	assert isFunction(func), "onInterval(): 1st arg not a function"
-	ms = Math.floor(1000 * secs)
-	if doLog
-		LOG "calling func every #{ms} ms."
-	interval = setInterval(func, ms)
-
-	return () ->
-		if doLog
-			LOG "destroying interval timer"
-		clearInterval interval

package/src/svelte.js

@@ -1,43 +0,0 @@
-// Generated by CoffeeScript 2.7.0
-  // svelte.coffee
-import {
-  assert,
-  croak
-} from '@jdeighan/base-utils/exceptions';
-
-import {
-  LOG
-} from '@jdeighan/base-utils/log';
-
-import {
-  isFunction
-} from '@jdeighan/base-utils';
-
-// ---------------------------------------------------------------------------
-//   svelteSourceCodeEsc - to display source code for a *.starbucks page
-export var svelteSourceCodeEsc = (str) => {
-  return str.replace(/\</g, '&lt;').replace(/\>/g, '&gt;').replace(/\{/g, '&lbrace;').replace(/\}/g, '&rbrace;').replace(/\$/g, '&dollar;');
-};
-
-// ---------------------------------------------------------------------------
-//   svelteHtmlEsc - after converting markdown
-export var svelteHtmlEsc = (str) => {
-  return str.replace(/\{/g, '&lbrace;').replace(/\}/g, '&rbrace;').replace(/\$/g, '&dollar;');
-};
-
-// ---------------------------------------------------------------------------
-export var onInterval = (func, secs, doLog = false) => {
-  var interval, ms;
-  assert(isFunction(func), "onInterval(): 1st arg not a function");
-  ms = Math.floor(1000 * secs);
-  if (doLog) {
-    LOG(`calling func every ${ms} ms.`);
-  }
-  interval = setInterval(func, ms);
-  return function() {
-    if (doLog) {
-      LOG("destroying interval timer");
-    }
-    return clearInterval(interval);
-  };
-};