@lumjs/compat 1.4.0 → 2.0.0

package/lib/v4/promise.js

@@ -1,392 +0,0 @@
-const {B,O,F} = require('@lumjs/core').types;
-
-/**
- * Build a *Promise* object with *Deferred* compatibility.
- *
- * @param {(object|boolean)} [options] Options for the `Promise` object.
- *
- *  If options is a `boolean`, it's assumed to be the `jquery` option.
- * 
- * @param {boolean} [options.jquery] Use `jQuery.Deferred` API?
- * - If `true`, use `this._extendJQuery(options)` to define methods.
- * - If `false`, use `this._extendInternal(options)` to define methods.
- *
- * @exports module:@lumjs/compat/v4/promise
- * @deprecated Use the Javascript `Promise` object directly.
- * 
- * If you need compatibility with the `jQuery.Deferred` API,
- * just use the `jQuery.Deferred` API itself.
- * 
- * If you need the `deferDone` or `deferFail` methods, use
- * this until the `@lumjs/defer` library is released.
- */
-function LumPromise(options)
-{
-  if (typeof options === B)
-  { // Assume the 'jquery' option was passed implicitly.
-    options = {jquery: options};
-  }
-  else if (typeof options !== O || options === null)
-  { // Ensure options is an object, and auto-select jQuery if it's loaded.
-    options = {jquery: (typeof jQuery === O)};
-  }
-
-  if (options.jquery)
-  {
-    this._extendJQuery(options)
-  }
-  else
-  {
-    this._extendInternal(options);
-  }
-}
-
-const lpp = LumPromise.prototype;
-
-/**
- * Add the methods from jQuery.Deferred to ourself.
- *
- * If jQuery is not loaded, this will throw an error.
- * 
- * @alias module:@lumjs/compat/v4/promise#_extendJQuery
- */
-lpp._extendJQuery = function (options)
-{
-  if (jQuery === undefined)
-  {
-    throw new Error("Cannot use 'jquery' without jQuery loaded.");
-  }
-  var def = jQuery.Deferred();
-  for (var f in def)
-  {
-    this[f] = def[f];
-  }
-}
-
-/**
- * Create our own internal represenation of the Deferred API.
- *
- *  Setters:             done(), fail(), always(), progress()
- *  Promise chaining:    then(), catch()
- *  Triggers:            resolve(), reject(), notify()
- *  Targetted triggers:  resolveWith(), rejectWith(), notifyWith()
- *  Info:                state()
- *
- * @alias module:@lumjs/compat/v4/promise#_extendInternal
- */
-lpp._extendInternal = function (options)
-{
-  // A copy of this for use in closures.
-  var self = this;
-
-  // Private storage for the state of the Promise.
-  var state = 'pending';
-
-  // Private storage for the arguments used to resolve/reject.
-  var final_args;
-
-  // Private storage for the 'this' object to use in callbacks.
-  var final_this = this;
-
-  var callbacks =
-  {
-    always: [],
-    done: [],
-    fail: [],
-    progress: [],
-  };
-
-  // Private function to run registered callbacks.
-  function apply_callbacks (name, args, current_this)
-  {
-    if (args === undefined)
-    {
-      args = final_args;
-    }
-    if (current_this === undefined)
-    {
-      current_this = final_this;
-    }
-    var cbs = callbacks[name];
-    if (cbs && cbs.length)
-    {
-      for (var i = 0; i < cbs.length; i++)
-      {
-        var cb = cbs[i];
-        cb.apply(current_this, args);
-      }
-    }
-  }
-
-  // Private function to create a listener.
-  function create_listener (name, validStates)
-  {
-    var listener = function ()
-    {
-      var args = Array.prototype.slice.call(arguments);
-      for (var i = 0; i < args.length; i++)
-      {
-        if (typeof args[i] === O && Array.isArray(args[i]))
-        { // An array of callbacks, recurse them.
-          listener.apply(self, args[i]);
-        }
-        else if (typeof args[i] === F)
-        {
-          if (state === 'pending')
-          { // Add the callback to the appropriate listener queue.
-            callbacks[name].push(args[i]);
-          }
-          else if (validStates.indexOf(state) != -1)
-          { // Execute the callback now.
-            args[i].apply(final_this, final_args);
-          }
-        }
-        else
-        {
-          console.warn("Unhandled parameter passed to "+name, args[i]);
-        }
-      }
-      return self;
-    }
-    return listener;
-  }
-
-  // Add our event assignment methods.
-  var meths = 
-  {
-    done: ['resolved'],
-    fail: ['rejected'],
-    always: ['resolved', 'rejected'],
-    progress: [],
-  };
-  for (var mname in meths)
-  {
-    var mstate = meths[mname];
-    self[mname] = create_listener(mname, mstate);
-  }
-
-  // Add our trigger methods.
-  self.resolve = function ()
-  {
-    if (state === 'pending')
-    {
-      var args = Array.prototype.slice.call(arguments);
-      if (args.length === 1 && typeof args[0] === O && 
-        typeof args[0].then === F)
-      { // Passed a promise. We'll 'then' it, and resolve again from it.
-        args[0].then(function ()
-        {
-          self.resolve.apply(self, arguments);
-        });
-      }
-      else
-      { // Not a promise, let's do this.
-        state = 'resolved';
-        final_args = args;
-        apply_callbacks('always');
-        apply_callbacks('done');
-      }
-    }
-  }
-
-  self.resolveWith = function (withObj)
-  {
-    if (state === 'pending')
-    {
-      final_this = withObj;
-      var resolveArgs = Array.prototype.slice.call(arguments, 1);
-      self.resolve.apply(self, resolveArgs);
-    }
-  }
-
-  self.reject = function ()
-  {
-    if (state === 'pending')
-    {
-      var args = Array.prototype.slice.call(arguments);
-      if (args.length === 1 && typeof args[0] === O && 
-        typeof args[0].then === F)
-      { // Passed a promise. We'll 'then' it, and resolve again from it.
-        args[0].then(null, function ()
-        {
-          self.reject.apply(self, arguments);
-        });
-      }
-      else
-      { // Not a promise, let's do this.
-        state = 'rejected';
-        final_args = args;
-        apply_callbacks('always');
-        apply_callbacks('fail');
-      }
-    }
-  }
-
-  self.rejectWith = function (withObj)
-  {
-    if (state === 'pending')
-    {
-      final_this = withObj;
-      var rejectArgs = Array.prototype.slice.call(arguments, 1);
-      self.reject.apply(self, rejectArgs);
-    }
-  }
-
-  self.notify = function ()
-  {
-    if (state === 'pending')
-    {
-      var args = Array.prototype.slice.call(arguments);
-      if (args.length === 1 && typeof args[0] === O && 
-        typeof args[0].then === F)
-      { // Passed a promise. We'll 'then' it, and resolve again from it.
-        args[0].then(null, null, function ()
-        {
-          self.notify.apply(self, arguments);
-        });
-      }
-      else
-      { // Not a promise, let's do this.
-        apply_callbacks('progress', args);
-      }
-    }
-  }
-
-  self.notifyWith = function (withObj)
-  {
-    if (state === 'pending')
-    {
-      var args = Array.prototype.slice.call(arguments, 1);
-      if (args.length === 1 && typeof args[0] === O && 
-        typeof args[0].then === F)
-      { // Passed a promise. We'll 'then' it, and resolve again from it.
-        args[0].then(null, null, function ()
-        {
-          var subargs = Array.prototype.slice.call(arguments);
-          subargs.unshift(withObj);
-          self.notifyWith.apply(self, subargs);
-        });
-      }
-      else
-      { // Not a promise, let's do this.
-        apply_callbacks('progress', args, withObj);
-      }
-    }
-  }
-
-  self.catch = function (failFilter)
-  {
-    return self.then(null, failFilter);
-  }
-
-  self.then = function (doneFilter, failFilter, progressFilter)
-  {
-    var newPromise = new LumPromise(false);
-
-    function make_callback (filterSpec)
-    {
-      var callback = function ()
-      {
-        var useWith = (this !== self);
-        var args = Array.prototype.slice.call(arguments);
-        var result = filterSpec.filter.apply(this, args);
-        if (useWith)
-        {
-          newPromise[filterSpec.methodWith](this, result);
-        }
-        else
-        {
-          newPromise[filterSpec.methodName](result);
-        }
-      }
-      return callback;
-    }
-
-    var filterSpecs =
-    {
-      done:
-      {
-        filter: doneFilter,
-        methodName: 'resolve',
-        methodWith: 'resolveWith',
-      },
-      fail:
-      {
-        filter: failFilter,
-        methodName: 'reject',
-        methodWith: 'rejectWith',
-      },
-      progress:
-      {
-        filter: progressFilter,
-        methodName: 'notify',
-        methodWith: 'notifyWith',
-      },
-    };
-
-    for (var onName in filterSpecs)
-    {
-      var filterSpec = filterSpecs[onName];
-      if (typeof filterSpec.filter === F)
-      {
-        var callback = make_callback(filterSpec);
-        self[onName](callback);
-      }
-    }
-
-    return newPromise;
-  }
-
-  self.state = function ()
-  {
-    return state;
-  }
-} // _extendInternal()
-
-/**
- * Execute a delayed 'done' action.
- *
- * @param mixed  obj      The object to send to the done().
- * @param str    ts       The textStatus to send to done().
- * @param mixed  xhr      Object to use as XHR (default is this.)
- * @param int    timeout  The timeout (in ms) defaults to 5.
- * 
- * @alias module:@lumjs/compat/v4/promise#deferDone
- */
-lpp.deferDone = function (obj, ts, xhr, timeout)
-{
-  var self = this;
-  if (timeout === undefined)
-    timeout = 5; // 5ms should be enough time to register .done events.
-  if (xhr === undefined)
-    xhr = self;
-  self.doneTimer = setTimeout(function() 
-  { 
-    self.resolve(obj, ts, xhr);
-  }, timeout);
-}
-
-/**
- * Execute a delayed 'fail' action.
- *
- * @param mixed  error    The message, code, or object to send to fail().
- * @param str    ts       The textStatus to send to fail().
- * @param mixed  xhr      Object to use as XHR (default is this.)
- * @param int    timeout  The timeout (in ms) defaults to 5.
- * 
- * @alias module:@lumjs/compat/v4/promise#deferFail
- */
-lpp.deferFail = function (error, ts, xhr, timeout)
-{
-  var self = this;
-  if (timeout === undefined)
-    timeout = 5;
-  if (xhr === undefined)
-    xhr = self;
-  self.failTimer = setTimeout(function () 
-  {
-    self.reject(xhr, ts, error);
-  }, timeout);
-}
-
-module.exports = LumPromise;

package/lib/v4/prop.js

@@ -1,164 +0,0 @@
-const core = require('@lumjs/core');
-const {isObj,isNil,notNil,isProperty,unbound,F} = core.types;
-const {cloneIfLocked} = core.obj;
-
-const {DESC,getDescriptor} = require('./descriptors');
-
-/**
- * A magic wrapper for Object.defineProperty()
- *
- * Rather than documenting the arguments in the usual manner, I'm
- * going to simply show all of the ways this method can be called.
- * 
- * Anywhere the `target` parameter is shown, this parameter can be an `object` or `function`.
- * It's the target to which we're adding new properties.
- * 
- * Anywhere the `property` parameter is shown, this parameter can be specified in two different
- * forms. The first and simplest is as a `string` in which case it's simply the name of the property we're adding.
- * The second more advanced form is as an `object`. If it is specified as an object, then it is a set of special options.
- * In this case, a property of that `property` object called `name` will be used as the name of the property.
- * If the `name` property is absent or `undefined`, it's the same as not passing the `property` parameter at all, 
- * and a *bound* function will be returned, using the custom options as its bound defaults.
- * 
- * See below the usage 
- *
- * `Lum.prop(object)`
- *
- *   Return a function that is a bound copy of this function with
- *   the object as it's first parameter.
- *
- * `Lum.prop(object, property)`
- *
- *   Add a property to the object which is mapped to a bound copy of
- *   this function with the object as it's first parameter.
- *
- * `Lum.prop(object, property, function, function)`
- *
- *   Add a getter and setter property with the default descriptor.
- *
- * `Lum.prop(object, property, function, function, object)`
- *
- *   Add a getter and setter property with specified Descriptor options.
- *   Do not use `get`, `set`, or `value` in the descriptor options.
- *
- * `Lum.prop(object, property, function, null, object)`
- *
- *   Add a getter only with specified descriptor options.
- *   Same restrictions to the descriptor options as above.
- *   You can specify `{}` as the descriptor options to use the defaults.
- *
- * `Lum.prop(object, property, null, function, object)`
- *
- *   Add a setter only with specified descriptor options.
- *   Same restrictions as above, and again you can use `{}` for defaults.
- *
- * `Lum.prop(object, property, !null)`
- *
- *   Add a property with the specified non-null value.
- *   This uses the default descriptor.
- *
- * `Lum.prop(object, property, !null, object)`
- *
- *   Add a property value with the specified descriptor options.
- *   Has the same restrictions to the descriptor options as above.
- *
- * `Lum.prop(object, property, null, object)`
- *
- *   Add a property using the descriptor object alone.
- *   Use the newer and shorter `def()` function instead.
- * 
- * `Lum.prop(object, property, Descriptor)`
- * 
- *   If you use `DESC.make()` or `descriptor()` to build a magic
- *   descriptor object, you can pass it and it'll be used with
- *   a few bonus features I need to document that aren't supported by
- *   the otherwise equivalent `def(object,property,descriptor)` call.
- *
- * @exports module:@lumjs/compat/v4/prop
- * @deprecated Replaced by `@lumjs/core.def` method. 
- */
-function prop(obj, name, arg1, arg2, arg3)
-{
-  let opts;
-
-  const isUnbound = unbound(this, true, true);
-
-  if (isObj(name))
-  { // A way to set some special options.
-    opts = name;
-    name = opts.name;
-  }
-  else if (isUnbound)
-  { // Use the default options.
-    opts = isObj(prop.options) ? prop.options : {};
-  }
-  else if (isObj(this))
-  { // This is already a bound copy, so `this` is the options.
-    opts = this;
-  }
-  else 
-  { // Something weird is going on here...
-    throw new Error("Invalid `this` in a prop() function call");
-  }
-
-  if (isNil(name))
-  { // A special case, returns a copy of this function bound to the object.
-    return prop.bind(opts, obj);
-  }
-  else if (!isProperty(name))
-  { // The property must in every other case be a string.
-    throw new Error("property name must be a string or Symbol");
-  }
-
-  let desc;
-
-  if (arg1 === undefined && arg2 === undefined)
-  { // Another special case, the property is a bound version of this.
-    return prop(obj, name, prop.bind(opts, obj));
-  }
-  else if (DESC.is(arg1) && arg2 === undefined)
-  { // Yet another special case.
-    if (arg1.isReady)
-    { // Already has a value or get/set properties assigned.
-      desc = arg1;
-    }
-    else 
-    { // We'll need to call setValue(), setGetter(), etc, then done().
-      return arg1.whenDone(function()
-      {
-        return prop(obj, name, this);
-      });
-    }
-  }
-  else if (typeof arg1 === F && typeof arg2 === F)
-  { // A getter and setter were specified.
-    desc = getDescriptor(isObj(arg3) ? cloneIfLocked(arg3) : DESC.CONF);
-    desc.setAccessor(arg1, arg2);
-  }
-  else if (isObj(arg3))
-  { // A custom descriptor for an accessor, find the accessor.
-    desc = getDescriptor(cloneIfLocked(arg3));
-    if (typeof arg1 === F)
-    { // A getter-only accessor.
-      desc.setGetter(arg1);
-    }
-    else if (typeof arg2 === F)
-    { // A setter-only accessor.
-      desc.setSetter(arg2);
-    }
-  }
-  else
-  { // Not a getter/setter, likely a standard value.
-    desc = getDescriptor(isObj(arg2) ? cloneIfLocked(arg2) : DESC.CONF);
-    
-    if (notNil(arg1))
-    { // If you really want a null 'value', use a custom descriptor.
-      desc.setValue(arg1);
-    }
-  }
-
-  // If we reached here, we should have a valid descriptor now.
-  return Object.defineProperty(obj, name, desc);
-}
-
-module.exports = prop;