stencil-quantum/dist/esm/index.js

Experience the quantum realm of stencil.

import { g as getElement, f as forceUpdate, h } from './index-44d29459.js';
import { h as hookComponent, P as Provider, t as throwQuantum } from './entanglement-f742a30d.js';
export { a as Catch, b as Context, C as ContextError, E as Entanglement, I as Implement, O as Observe, c as Provide, P as Provider, Q as QuantumError, R as React, T as Throw, h as hookComponent, l as log, n as nop, t as throwQuantum } from './entanglement-f742a30d.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];
    hookComponent(prototype, "componentWillLoad", obj => {
      const el = getElement(obj);
      try {
        provider = 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 = Provider.find(el, opts.emitter);
          if (value)
            provider.retrieve().emit(_event, value);
          provider.hook(el);
        }
        catch (err) {
          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;
      forceUpdate(el);
    };
    hookComponent(prototype, "componentWillLoad", obj => {
      let provider;
      let lastEmitter;
      el = getElement(obj);
      const findAndListen = (onErr = (e) => { }) => {
        try {
          if (!provider) {
            provider = 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 => 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 h("quantum-consumer", { bind: props.bind, onUpdate: e => props.onUpdate(e.detail.value, e.detail.provider) }, children);
}
function QuantumProvide(props, children) {
  return 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>;

*/

export { Emit, QuantumConsume, QuantumProvide, Receive, qa, qt };