@difizen/mana-observable/lib/notifiable.js

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.Notifiable = void 0;
var _manaCommon = require("@difizen/mana-common");
var _core = require("./core");
var _notifier = require("./notifier");
var _utils = require("./utils");
/* eslint-disable @typescript-eslint/no-explicit-any */
/* eslint-disable prefer-spread */
var Notifiable;
(function (_Notifiable) {
  var token = _Notifiable.token = Symbol('Notifiable');
  function is(target) {
    return _utils.Observability.isObject(target) && !!target[_core.ObservableSymbol.Notifier];
  }
  _Notifiable.is = is;
  function getNotifier(target) {
    return target[_core.ObservableSymbol.Notifier];
  }
  _Notifiable.getNotifier = getNotifier;
  function tryGetNotifier(target) {
    if (is(target)) {
      return getNotifier(target);
    }
    return undefined;
  }
  _Notifiable.tryGetNotifier = tryGetNotifier;
  function set(target, value) {
    Reflect.defineMetadata(token, value, target);
  }
  _Notifiable.set = set;
  function get(target) {
    return Reflect.getMetadata(token, target);
  }
  _Notifiable.get = get;
  function canBeNotifiable(value) {
    if (!_utils.Observability.isObject(value)) {
      return false;
    }
    if (Object.isFrozen(value)) {
      return false;
    }
    if (value instanceof Array) {
      return true;
    }
    if (value instanceof Map) {
      return true;
    }
    if ((0, _manaCommon.isPlainObject)(value)) {
      return true;
    }
    return false;
  }
  _Notifiable.canBeNotifiable = canBeNotifiable;
  function transform(target) {
    if (is(target)) {
      return target;
    }
    if (!_utils.Observability.canBeObservable(target)) {
      return target;
    }
    var origin = _utils.Observability.getOrigin(target);
    var notifiable = Notifiable.get(origin);
    if (notifiable) {
      return notifiable;
    }
    if (origin instanceof Array) {
      return transformArray(origin);
    }
    if (origin instanceof Map) {
      return transformMap(origin);
    }
    if ((0, _manaCommon.isPlainObject)(origin)) {
      return transformPlainObject(origin);
    }
    return target;
  }
  _Notifiable.transform = transform;
  function transformArray(target) {
    var notifier = _notifier.Notifier.getOrCreate(target);
    var notifiable = new Proxy(target, {
      get: function get(self, property) {
        if (property === _core.ObservableSymbol.Notifier) {
          return notifier;
        }
        if (property === _core.ObservableSymbol.Self) {
          return self;
        }
        var result = Reflect.get(self, property);
        if ((0, _utils.isReadonly)(target, property)) {
          return result;
        }
        var origin = _utils.Observability.getOrigin(result);
        return Notifiable.transform(origin);
      },
      set: function set(self, prop, value) {
        var result = Reflect.set(self, prop, value);
        notifier.notify(value);
        return result;
      }
    });
    set(target, notifiable);
    return notifiable;
  }
  _Notifiable.transformArray = transformArray;
  function transformPlainObject(target) {
    var notifier = _notifier.Notifier.getOrCreate(target);
    var notifiable = new Proxy(target, {
      get: function get(self, property) {
        if (property === _core.ObservableSymbol.Notifier) {
          return notifier;
        }
        if (property === _core.ObservableSymbol.Self) {
          return self;
        }
        var result = Reflect.get(self, property);
        if ((0, _utils.isReadonly)(target, property)) {
          return result;
        }
        var origin = _utils.Observability.getOrigin(result);
        return Notifiable.transform(origin);
      },
      set: function set(self, prop, value) {
        var result = Reflect.set(self, prop, value);
        notifier.notify(value);
        return result;
      },
      deleteProperty: function deleteProperty(self, prop) {
        var result = Reflect.deleteProperty(self, prop);
        notifier.notify(undefined);
        return result;
      }
    });
    set(target, notifiable);
    return notifiable;
  }
  _Notifiable.transformPlainObject = transformPlainObject;
  function transformMap(target) {
    var notifier = _notifier.Notifier.getOrCreate(target);
    var notifiable = new Proxy(target, {
      get: function get(self, prop) {
        if (prop === _core.ObservableSymbol.Notifier) {
          return notifier;
        }
        if (prop === _core.ObservableSymbol.Self) {
          return self;
        }
        var result;
        switch (prop) {
          case 'delete':
            return function () {
              for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
                args[_key] = arguments[_key];
              }
              result = self.delete.apply(self, args);
              notifier.notify(undefined);
              return result;
            };
          case 'clear':
            return function () {
              for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
                args[_key2] = arguments[_key2];
              }
              result = self.clear.apply(self, args);
              notifier.notify(undefined);
              return result;
            };
          case 'set':
            return function () {
              for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
                args[_key3] = arguments[_key3];
              }
              result = self.set.apply(self, args);
              notifier.notify(undefined);
              return result;
            };
          case 'get':
            return function () {
              for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
                args[_key4] = arguments[_key4];
              }
              result = self.get.apply(self, args);
              var origin = _utils.Observability.getOrigin(result);
              return Notifiable.transform(origin);
            };
          default:
            result = Reflect.get(self, prop);
            if (typeof result === 'function') {
              return result.bind(self);
            } else {
              var origin = _utils.Observability.getOrigin(result);
              return Notifiable.transform(origin);
            }
        }
      }
    });
    set(target, notifiable);
    return notifiable;
  }
  _Notifiable.transformMap = transformMap;
})(Notifiable || (exports.Notifiable = Notifiable = {}));