stencil-quantum/dist/cjs/index.cjs.js

Experience the quantum realm of stencil.

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

const index = require('./index-059fa27d.js');
const entanglement = require('./entanglement-47192bf8.js');

function Emit(opts) {
  return function (prototype, propertyName) {
    var _a;
    const _event = (_a = opts.on) !== null && _a !== void 0 ? _a : propertyName;
    let provider;
    let value = prototype[propertyName];
    entanglement.hookComponent(prototype, "componentWillLoad", obj => {
      const el = index.getElement(obj);
      try {
        provider = entanglement.Provider.find(el, opts.emitter, opts.namespace);
        if (value)
          provider.retrieve().emit(_event, value);
        provider.hook(el);
      }
      catch (err) {
      }
      return () => {
        try {
          if (provider)
            provider.unhook(el);
          provider = entanglement.Provider.find(el, opts.emitter);
          if (value)
            provider.retrieve().emit(_event, value);
          provider.hook(el);
        }
        catch (err) {
          entanglement.throwQuantum(el, err);
        }
      };
    });
    if (delete prototype[propertyName]) {
      Object.defineProperty(prototype, propertyName, {
        get: () => value,
        set: (v) => {
          provider === null || provider === void 0 ? void 0 : provider.retrieve().emit(_event, v);
          value = v;
        },
        enumerable: true,
        configurable: true
      });
    }
  };
}
function Receive(opts) {
  return function (prototype, propertyName) {
    var _a;
    const _event = (_a = opts.on) !== null && _a !== void 0 ? _a : propertyName;
    let el;
    let value = prototype[propertyName];
    const onValue = (v) => {
      value = v;
      index.forceUpdate(el);
    };
    entanglement.hookComponent(prototype, "componentWillLoad", obj => {
      let provider;
      let lastEmitter;
      el = index.getElement(obj);
      const findAndListen = (onErr = (e) => { }) => {
        try {
          if (!provider) {
            provider = entanglement.Provider.find(el, opts.emitter, opts.namespace);
            provider.listen(emitter => {
              lastEmitter === null || lastEmitter === void 0 ? void 0 : lastEmitter.off(_event, onValue);
              emitter.on(_event, onValue);
              lastEmitter = emitter;
            });
          }
        }
        catch (err) {
          onErr(err);
        }
      };
      findAndListen();
      return () => findAndListen(err => entanglement.throwQuantum(el, err));
    });
    if (delete prototype[propertyName]) {
      Object.defineProperty(prototype, propertyName, {
        get: () => value,
        set: onValue,
        enumerable: true,
        configurable: true
      });
    }
  };
}

function qt(opts = {}) {
  return opts;
}
function qa(opts = {}) {
  return opts;
}

function QuantumConsume(props, children) {
  return index.h("quantum-consumer", { bind: props.bind, onUpdate: e => props.onUpdate(e.detail.value, e.detail.provider) }, children);
}
function QuantumProvide(props, children) {
  return index.h("quantum-provider", { bind: props.bind, onUpdate: e => { var _a; return (_a = props.onUpdate) === null || _a === void 0 ? void 0 : _a.call(props, e.detail.value, e.detail.provider); }, value: props.value }, children);
}
/*

const test = new Entanglement({
    test: qt<boolean>()
});

function testJSX()
{
    return <Consumer bind={test.get("test")} onValue={(value, provider) => {provider.provide(!value)}}></Consumer>
}

function testFn()
{
    return <div>
        {Consumer({bind: test.get("test"), onValue: value => {}})}
    </div>
}

type B = QuantumKey<boolean, typeof test>;
type C = B["config"];
type N = B["name"];
type T = ResolveQuantumKey<B, C>;

*/

exports.Catch = entanglement.Catch;
exports.Context = entanglement.Context;
exports.ContextError = entanglement.ContextError;
exports.Entanglement = entanglement.Entanglement;
exports.Implement = entanglement.Implement;
exports.Observe = entanglement.Observe;
exports.Provide = entanglement.Provide;
exports.Provider = entanglement.Provider;
exports.QuantumError = entanglement.QuantumError;
exports.React = entanglement.React;
exports.Throw = entanglement.Throw;
exports.hookComponent = entanglement.hookComponent;
exports.log = entanglement.log;
exports.nop = entanglement.nop;
exports.throwQuantum = entanglement.throwQuantum;
exports.Emit = Emit;
exports.QuantumConsume = QuantumConsume;
exports.QuantumProvide = QuantumProvide;
exports.Receive = Receive;
exports.qa = qa;
exports.qt = qt;