@lumjs/core 1.10.0 → 1.11.0

package/lib/observable.js

@@ -1,5 +1,7 @@
 
 const {B,F,S,def,isObj,isComplex,TYPES,console} = require('./types');
+const {duplicateAll: clone} = require('./obj/copyall');
+const lock = Object.freeze;
 
 /**
  * Make an object support the *Observable* API.
@@ -11,29 +13,57 @@ const {B,F,S,def,isObj,isComplex,TYPES,console} = require('./types');
  * @param {string} [opts.wildcard='*'] The event name used as a wildcard. 
  * @param {boolean} [opts.wrapthis=false] If `true`, `this` will be a wrapper.
  * 
- * If 'wrapthis' is true, the function will be called with a wrapper object as 
- * the 'this' variable instead of the target object. The wrapper will be:
+ * If `wrapthis` is `true`, the function will be called with a wrapper object 
+ * as the `this` variable instead of the target object. The wrapper will be:
  *
  * ```js
  * {
+ *   isObservable:
+ *   {
+ *     event: true,   // This is an event data object.
+ *     target: false, // This is not the target object.
+ *   },
  *   self: el,        // The target object.
  *   name: event,     // The event name that was triggered.
  *   wildcard: bool,  // Will be true if this was a wildcard event handler.
  *   func: function,  // The function being called.
+ *   args: array,     // The arguments passed to trigger.
  * }
  * ```
  * 
- * @param {boolean} [opts.addname=!opts.wrapthis] If `true` callbacks with 
- *   multiple events will have the name of the triggered event added as
- *   the first parameter.
+ * The object will be frozen so its values cannot be modified.
+ * 
+ * @param {boolean} [opts.wrapargs=false] If `true`, the functions will be
+ * passed a single object as the sole argument. The object will be the same
+ * as the one from `opts.wrapthis`.
+ * 
+ * @param {boolean} [opts.addname] If `true` callbacks with 
+ * multiple events will have the name of the triggered event added as
+ * the first parameter.
+ * 
+ * If either `wrapthis` or `wrapargs` are `true`, then this will default
+ * to `false`, otherwise it will default to `true`.
+ * 
+ * @param {boolean} [opts.addis] If `true` add a read-only, frozen
+ * object property named `isObservable` with the value:
+ * 
+ * ```js
+ * {
+ *   event: false, // This is not an event data object.
+ *   target: true, // This is the target object.
+ * }
+ * ```
+ *
+ * If either `wrapthis` or `wrapargs` are `true`, then this will default
+ * to `true`, otherwise it will default to `false`.
  * 
- * @param {boolean} [opts.addis=opts.wrapthis] If `true` add immutable
- *   property named `isObservable` which will have a value of `true`.
  * @param {string} [opts.addme] If set, add a method with this name
- *   to the object, which is a version of `observable()` with the
- *   default options being the same as the current `opts`.
- *   If `opts.wrapthis` is `true`, then this defaults to `'makeObservable'`.
- *   In any other case it defaults to `null`.
+ * to the `el` object, which is a version of `observable()` with the
+ * default options being the same as the current `opts`.
+ * 
+ * @param {string} [opts.addre] If set, add a method with this name
+ * to the `el` object, which is a function that can re-build the
+ * observable API methods with new `opts` replacing the old ones. 
  *
  * @returns {object} el
  * 
@@ -69,30 +99,46 @@ function observable (el={}, opts={})
     ? opts.wildcard
     : '*';
 
-  const wrapthis = (typeof opts.wrapthis === 'boolean') 
+  const wrapthis = (typeof opts.wrapthis === B) 
     ? opts.wrapthis 
     : false;
 
-  const addname = (typeof opts.addname === 'boolean') 
+  const wrapargs = (typeof opts.wrapargs === B)
+    ? opts.wrapargs
+    : false;
+
+  const wrapped = (wrapthis || wrapargs);
+
+  const addname = (typeof opts.addname === B) 
     ? opts.addname 
-    : !wrapthis;
+    : !wrapped;
 
-  const addis = (typeof opts.addis === 'boolean')
+  const addis = (typeof opts.addis === B)
     ? opts.addis
-    : wrapthis;
+    : wrapped;
 
   const validIdent = /^[a-zA-Z_$][0-9a-zA-Z_$]*$/;
 
-  const addme = (typeof opts.addme === 'string'
+  const addme = (typeof opts.addme === S
     && validIdent.test(opts.addme))
     ? opts.addme
-    : (wrapthis ? 'makeObservable' : null);
+    : null;
+
+  const addre = (typeof opts.addre === S
+    && validIdent.test(opts.addre))
+    ? opts.addre
+    : null;
 
   const slice = Array.prototype.slice;
 
   function onEachEvent (e, fn) 
   { 
-    e.replace(/\S+/g, fn);
+    const es = e.split(/\s+/);
+    const me = es.length > 1;
+    for (e of es)
+    {
+      fn(e, me);
+    }
   }
 
   const add = def(el);
@@ -102,29 +148,28 @@ function observable (el={}, opts={})
     if (fn.busy) return;
     fn.busy = 1;
 
-    let fthis;
+    let fobj;
 
-    if (wrapthis)
-    {
+    if (wrapthis || wrapargs)
+    { // Something is going to use our wrapper object.
       const isWild = (name === wildcard);
       const fname = isWild ? (addname ? args[0] : args.shift()) : name;
-      fthis = 
-      {
+      fobj = 
+      lock({
+        isObservable: lock({event: true, target: false}),
         self: el,
         name: fname,
         func: fn,
         wildcard: isWild,
-      };
-    }
-    else
-    {
-      fthis = el;
+        args,
+      });
     }
 
-    let fargs = (fn.typed && addname) ? [name].concat(args) : args;
-
+    const fthis = wrapthis ? fobj : el;
+    const fargs = wrapargs ? [fobj] 
+      : ((fn.typed && addname) ? [name].concat(args) : args);
+    
     fn.apply(fthis, fargs);
-
     fn.busy = 0;
   }
 
@@ -147,10 +192,10 @@ function observable (el={}, opts={})
       return el;
     }
 
-    onEachEvent(events, function(name, pos) 
+    onEachEvent(events, function(name, typed) 
     {
       (callbacks[name] = callbacks[name] || []).push(fn);
-      fn.typed = pos > 0;
+      fn.typed = typed;
     });
 
     return el;
@@ -244,28 +289,28 @@ function observable (el={}, opts={})
 
   if (addis)
   {
-    add('isObservable', true);
+    add('isObservable', lock({event: false, target: true}));
   }
 
   if (addme)
   { // Add a wrapper for observable() that sets new default options.
-    const ourProps = Object.keys(opts);
     add(addme, function (obj=null, mopts={})
     {
-      if (ourProps.length > 0)
-      {
-        for (const prop of ourProps)
-        {
-          if (mopts[prop] === undefined)
-          {
-            mopts[prop] = opts[prop];
-          }
-        }
-      }
-      return observable(obj, mopts);
+      return observable(obj, clone(opts, mopts));
+    });
+  }
+
+  if (addre)
+  { // Add a method to change the observable options.
+    add(addre, function(opts={})
+    {
+      return observable(el, opts);
     });
   }
 
+  // Metadata
+  add('$$observable$$', lock({opts, observable}));
+
   return el
 
 } // observable()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumjs/core",
-  "version": "1.10.0",
+  "version": "1.11.0",
   "main": "lib/index.js",
   "exports":
   {