@agendize/vue-tools 0.0.0 → 0.0.1

package/dist/index.d.ts

@@ -1 +1,3 @@
+import { useBlocState } from "./bloc/useBlocState";
 export * from './bloc/Bloc';
+export { useBlocState };

package/dist/vue-tools.es.js

@@ -4,6 +4,761 @@ var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
+function makeMap(str, expectsLowerCase) {
+  const map = /* @__PURE__ */ Object.create(null);
+  const list = str.split(",");
+  for (let i = 0; i < list.length; i++) {
+    map[list[i]] = true;
+  }
+  return expectsLowerCase ? (val) => !!map[val.toLowerCase()] : (val) => !!map[val];
+}
+const NO = () => false;
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+const hasOwn = (val, key) => hasOwnProperty.call(val, key);
+const isArray = Array.isArray;
+const isMap = (val) => toTypeString(val) === "[object Map]";
+const isFunction = (val) => typeof val === "function";
+const isString = (val) => typeof val === "string";
+const isSymbol = (val) => typeof val === "symbol";
+const isObject = (val) => val !== null && typeof val === "object";
+const isPromise = (val) => {
+  return isObject(val) && isFunction(val.then) && isFunction(val.catch);
+};
+const objectToString = Object.prototype.toString;
+const toTypeString = (value) => objectToString.call(value);
+const toRawType = (value) => {
+  return toTypeString(value).slice(8, -1);
+};
+const isIntegerKey = (key) => isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
+const hasChanged = (value, oldValue) => !Object.is(value, oldValue);
+const createDep = (effects) => {
+  const dep = new Set(effects);
+  dep.w = 0;
+  dep.n = 0;
+  return dep;
+};
+const wasTracked = (dep) => (dep.w & trackOpBit) > 0;
+const newTracked = (dep) => (dep.n & trackOpBit) > 0;
+const targetMap = /* @__PURE__ */ new WeakMap();
+let trackOpBit = 1;
+let activeEffect;
+const ITERATE_KEY = Symbol("");
+const MAP_KEY_ITERATE_KEY = Symbol("");
+let shouldTrack = true;
+const trackStack = [];
+function pauseTracking() {
+  trackStack.push(shouldTrack);
+  shouldTrack = false;
+}
+function resetTracking() {
+  const last = trackStack.pop();
+  shouldTrack = last === void 0 ? true : last;
+}
+function track(target, type, key) {
+  if (shouldTrack && activeEffect) {
+    let depsMap = targetMap.get(target);
+    if (!depsMap) {
+      targetMap.set(target, depsMap = /* @__PURE__ */ new Map());
+    }
+    let dep = depsMap.get(key);
+    if (!dep) {
+      depsMap.set(key, dep = createDep());
+    }
+    trackEffects(dep);
+  }
+}
+function trackEffects(dep, debuggerEventExtraInfo) {
+  let shouldTrack2 = false;
+  {
+    if (!newTracked(dep)) {
+      dep.n |= trackOpBit;
+      shouldTrack2 = !wasTracked(dep);
+    }
+  }
+  if (shouldTrack2) {
+    dep.add(activeEffect);
+    activeEffect.deps.push(dep);
+  }
+}
+function trigger(target, type, key, newValue, oldValue, oldTarget) {
+  const depsMap = targetMap.get(target);
+  if (!depsMap) {
+    return;
+  }
+  let deps = [];
+  if (type === "clear") {
+    deps = [...depsMap.values()];
+  } else if (key === "length" && isArray(target)) {
+    depsMap.forEach((dep, key2) => {
+      if (key2 === "length" || key2 >= newValue) {
+        deps.push(dep);
+      }
+    });
+  } else {
+    if (key !== void 0) {
+      deps.push(depsMap.get(key));
+    }
+    switch (type) {
+      case "add":
+        if (!isArray(target)) {
+          deps.push(depsMap.get(ITERATE_KEY));
+          if (isMap(target)) {
+            deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
+          }
+        } else if (isIntegerKey(key)) {
+          deps.push(depsMap.get("length"));
+        }
+        break;
+      case "delete":
+        if (!isArray(target)) {
+          deps.push(depsMap.get(ITERATE_KEY));
+          if (isMap(target)) {
+            deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
+          }
+        }
+        break;
+      case "set":
+        if (isMap(target)) {
+          deps.push(depsMap.get(ITERATE_KEY));
+        }
+        break;
+    }
+  }
+  if (deps.length === 1) {
+    if (deps[0]) {
+      {
+        triggerEffects(deps[0]);
+      }
+    }
+  } else {
+    const effects = [];
+    for (const dep of deps) {
+      if (dep) {
+        effects.push(...dep);
+      }
+    }
+    {
+      triggerEffects(createDep(effects));
+    }
+  }
+}
+function triggerEffects(dep, debuggerEventExtraInfo) {
+  const effects = isArray(dep) ? dep : [...dep];
+  for (const effect of effects) {
+    if (effect.computed) {
+      triggerEffect(effect);
+    }
+  }
+  for (const effect of effects) {
+    if (!effect.computed) {
+      triggerEffect(effect);
+    }
+  }
+}
+function triggerEffect(effect, debuggerEventExtraInfo) {
+  if (effect !== activeEffect || effect.allowRecurse) {
+    if (effect.scheduler) {
+      effect.scheduler();
+    } else {
+      effect.run();
+    }
+  }
+}
+const isNonTrackableKeys = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`);
+const builtInSymbols = new Set(
+  /* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(isSymbol)
+);
+const get = /* @__PURE__ */ createGetter();
+const readonlyGet = /* @__PURE__ */ createGetter(true);
+const arrayInstrumentations = /* @__PURE__ */ createArrayInstrumentations();
+function createArrayInstrumentations() {
+  const instrumentations = {};
+  ["includes", "indexOf", "lastIndexOf"].forEach((key) => {
+    instrumentations[key] = function(...args) {
+      const arr = toRaw(this);
+      for (let i = 0, l = this.length; i < l; i++) {
+        track(arr, "get", i + "");
+      }
+      const res = arr[key](...args);
+      if (res === -1 || res === false) {
+        return arr[key](...args.map(toRaw));
+      } else {
+        return res;
+      }
+    };
+  });
+  ["push", "pop", "shift", "unshift", "splice"].forEach((key) => {
+    instrumentations[key] = function(...args) {
+      pauseTracking();
+      const res = toRaw(this)[key].apply(this, args);
+      resetTracking();
+      return res;
+    };
+  });
+  return instrumentations;
+}
+function createGetter(isReadonly2 = false, shallow = false) {
+  return function get2(target, key, receiver) {
+    if (key === "__v_isReactive") {
+      return !isReadonly2;
+    } else if (key === "__v_isReadonly") {
+      return isReadonly2;
+    } else if (key === "__v_isShallow") {
+      return shallow;
+    } else if (key === "__v_raw" && receiver === (isReadonly2 ? shallow ? shallowReadonlyMap : readonlyMap : shallow ? shallowReactiveMap : reactiveMap).get(target)) {
+      return target;
+    }
+    const targetIsArray = isArray(target);
+    if (!isReadonly2 && targetIsArray && hasOwn(arrayInstrumentations, key)) {
+      return Reflect.get(arrayInstrumentations, key, receiver);
+    }
+    const res = Reflect.get(target, key, receiver);
+    if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
+      return res;
+    }
+    if (!isReadonly2) {
+      track(target, "get", key);
+    }
+    if (shallow) {
+      return res;
+    }
+    if (isRef(res)) {
+      return targetIsArray && isIntegerKey(key) ? res : res.value;
+    }
+    if (isObject(res)) {
+      return isReadonly2 ? readonly(res) : reactive(res);
+    }
+    return res;
+  };
+}
+const set = /* @__PURE__ */ createSetter();
+function createSetter(shallow = false) {
+  return function set2(target, key, value, receiver) {
+    let oldValue = target[key];
+    if (isReadonly(oldValue) && isRef(oldValue) && !isRef(value)) {
+      return false;
+    }
+    if (!shallow) {
+      if (!isShallow(value) && !isReadonly(value)) {
+        oldValue = toRaw(oldValue);
+        value = toRaw(value);
+      }
+      if (!isArray(target) && isRef(oldValue) && !isRef(value)) {
+        oldValue.value = value;
+        return true;
+      }
+    }
+    const hadKey = isArray(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn(target, key);
+    const result = Reflect.set(target, key, value, receiver);
+    if (target === toRaw(receiver)) {
+      if (!hadKey) {
+        trigger(target, "add", key, value);
+      } else if (hasChanged(value, oldValue)) {
+        trigger(target, "set", key, value);
+      }
+    }
+    return result;
+  };
+}
+function deleteProperty(target, key) {
+  const hadKey = hasOwn(target, key);
+  target[key];
+  const result = Reflect.deleteProperty(target, key);
+  if (result && hadKey) {
+    trigger(target, "delete", key, void 0);
+  }
+  return result;
+}
+function has(target, key) {
+  const result = Reflect.has(target, key);
+  if (!isSymbol(key) || !builtInSymbols.has(key)) {
+    track(target, "has", key);
+  }
+  return result;
+}
+function ownKeys(target) {
+  track(target, "iterate", isArray(target) ? "length" : ITERATE_KEY);
+  return Reflect.ownKeys(target);
+}
+const mutableHandlers = {
+  get,
+  set,
+  deleteProperty,
+  has,
+  ownKeys
+};
+const readonlyHandlers = {
+  get: readonlyGet,
+  set(target, key) {
+    return true;
+  },
+  deleteProperty(target, key) {
+    return true;
+  }
+};
+const toShallow = (value) => value;
+const getProto = (v) => Reflect.getPrototypeOf(v);
+function get$1(target, key, isReadonly2 = false, isShallow2 = false) {
+  target = target["__v_raw"];
+  const rawTarget = toRaw(target);
+  const rawKey = toRaw(key);
+  if (!isReadonly2) {
+    if (key !== rawKey) {
+      track(rawTarget, "get", key);
+    }
+    track(rawTarget, "get", rawKey);
+  }
+  const { has: has2 } = getProto(rawTarget);
+  const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
+  if (has2.call(rawTarget, key)) {
+    return wrap(target.get(key));
+  } else if (has2.call(rawTarget, rawKey)) {
+    return wrap(target.get(rawKey));
+  } else if (target !== rawTarget) {
+    target.get(key);
+  }
+}
+function has$1(key, isReadonly2 = false) {
+  const target = this["__v_raw"];
+  const rawTarget = toRaw(target);
+  const rawKey = toRaw(key);
+  if (!isReadonly2) {
+    if (key !== rawKey) {
+      track(rawTarget, "has", key);
+    }
+    track(rawTarget, "has", rawKey);
+  }
+  return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
+}
+function size(target, isReadonly2 = false) {
+  target = target["__v_raw"];
+  !isReadonly2 && track(toRaw(target), "iterate", ITERATE_KEY);
+  return Reflect.get(target, "size", target);
+}
+function add(value) {
+  value = toRaw(value);
+  const target = toRaw(this);
+  const proto = getProto(target);
+  const hadKey = proto.has.call(target, value);
+  if (!hadKey) {
+    target.add(value);
+    trigger(target, "add", value, value);
+  }
+  return this;
+}
+function set$1(key, value) {
+  value = toRaw(value);
+  const target = toRaw(this);
+  const { has: has2, get: get2 } = getProto(target);
+  let hadKey = has2.call(target, key);
+  if (!hadKey) {
+    key = toRaw(key);
+    hadKey = has2.call(target, key);
+  }
+  const oldValue = get2.call(target, key);
+  target.set(key, value);
+  if (!hadKey) {
+    trigger(target, "add", key, value);
+  } else if (hasChanged(value, oldValue)) {
+    trigger(target, "set", key, value);
+  }
+  return this;
+}
+function deleteEntry(key) {
+  const target = toRaw(this);
+  const { has: has2, get: get2 } = getProto(target);
+  let hadKey = has2.call(target, key);
+  if (!hadKey) {
+    key = toRaw(key);
+    hadKey = has2.call(target, key);
+  }
+  get2 ? get2.call(target, key) : void 0;
+  const result = target.delete(key);
+  if (hadKey) {
+    trigger(target, "delete", key, void 0);
+  }
+  return result;
+}
+function clear() {
+  const target = toRaw(this);
+  const hadItems = target.size !== 0;
+  const result = target.clear();
+  if (hadItems) {
+    trigger(target, "clear", void 0, void 0);
+  }
+  return result;
+}
+function createForEach(isReadonly2, isShallow2) {
+  return function forEach(callback, thisArg) {
+    const observed = this;
+    const target = observed["__v_raw"];
+    const rawTarget = toRaw(target);
+    const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
+    !isReadonly2 && track(rawTarget, "iterate", ITERATE_KEY);
+    return target.forEach((value, key) => {
+      return callback.call(thisArg, wrap(value), wrap(key), observed);
+    });
+  };
+}
+function createIterableMethod(method, isReadonly2, isShallow2) {
+  return function(...args) {
+    const target = this["__v_raw"];
+    const rawTarget = toRaw(target);
+    const targetIsMap = isMap(rawTarget);
+    const isPair = method === "entries" || method === Symbol.iterator && targetIsMap;
+    const isKeyOnly = method === "keys" && targetIsMap;
+    const innerIterator = target[method](...args);
+    const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
+    !isReadonly2 && track(rawTarget, "iterate", isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
+    return {
+      next() {
+        const { value, done } = innerIterator.next();
+        return done ? { value, done } : {
+          value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
+          done
+        };
+      },
+      [Symbol.iterator]() {
+        return this;
+      }
+    };
+  };
+}
+function createReadonlyMethod(type) {
+  return function(...args) {
+    return type === "delete" ? false : this;
+  };
+}
+function createInstrumentations() {
+  const mutableInstrumentations2 = {
+    get(key) {
+      return get$1(this, key);
+    },
+    get size() {
+      return size(this);
+    },
+    has: has$1,
+    add,
+    set: set$1,
+    delete: deleteEntry,
+    clear,
+    forEach: createForEach(false, false)
+  };
+  const shallowInstrumentations2 = {
+    get(key) {
+      return get$1(this, key, false, true);
+    },
+    get size() {
+      return size(this);
+    },
+    has: has$1,
+    add,
+    set: set$1,
+    delete: deleteEntry,
+    clear,
+    forEach: createForEach(false, true)
+  };
+  const readonlyInstrumentations2 = {
+    get(key) {
+      return get$1(this, key, true);
+    },
+    get size() {
+      return size(this, true);
+    },
+    has(key) {
+      return has$1.call(this, key, true);
+    },
+    add: createReadonlyMethod("add"),
+    set: createReadonlyMethod("set"),
+    delete: createReadonlyMethod("delete"),
+    clear: createReadonlyMethod("clear"),
+    forEach: createForEach(true, false)
+  };
+  const shallowReadonlyInstrumentations2 = {
+    get(key) {
+      return get$1(this, key, true, true);
+    },
+    get size() {
+      return size(this, true);
+    },
+    has(key) {
+      return has$1.call(this, key, true);
+    },
+    add: createReadonlyMethod("add"),
+    set: createReadonlyMethod("set"),
+    delete: createReadonlyMethod("delete"),
+    clear: createReadonlyMethod("clear"),
+    forEach: createForEach(true, true)
+  };
+  const iteratorMethods = ["keys", "values", "entries", Symbol.iterator];
+  iteratorMethods.forEach((method) => {
+    mutableInstrumentations2[method] = createIterableMethod(method, false, false);
+    readonlyInstrumentations2[method] = createIterableMethod(method, true, false);
+    shallowInstrumentations2[method] = createIterableMethod(method, false, true);
+    shallowReadonlyInstrumentations2[method] = createIterableMethod(method, true, true);
+  });
+  return [
+    mutableInstrumentations2,
+    readonlyInstrumentations2,
+    shallowInstrumentations2,
+    shallowReadonlyInstrumentations2
+  ];
+}
+const [mutableInstrumentations, readonlyInstrumentations, shallowInstrumentations, shallowReadonlyInstrumentations] = /* @__PURE__ */ createInstrumentations();
+function createInstrumentationGetter(isReadonly2, shallow) {
+  const instrumentations = shallow ? isReadonly2 ? shallowReadonlyInstrumentations : shallowInstrumentations : isReadonly2 ? readonlyInstrumentations : mutableInstrumentations;
+  return (target, key, receiver) => {
+    if (key === "__v_isReactive") {
+      return !isReadonly2;
+    } else if (key === "__v_isReadonly") {
+      return isReadonly2;
+    } else if (key === "__v_raw") {
+      return target;
+    }
+    return Reflect.get(hasOwn(instrumentations, key) && key in target ? instrumentations : target, key, receiver);
+  };
+}
+const mutableCollectionHandlers = {
+  get: /* @__PURE__ */ createInstrumentationGetter(false, false)
+};
+const readonlyCollectionHandlers = {
+  get: /* @__PURE__ */ createInstrumentationGetter(true, false)
+};
+const reactiveMap = /* @__PURE__ */ new WeakMap();
+const shallowReactiveMap = /* @__PURE__ */ new WeakMap();
+const readonlyMap = /* @__PURE__ */ new WeakMap();
+const shallowReadonlyMap = /* @__PURE__ */ new WeakMap();
+function targetTypeMap(rawType) {
+  switch (rawType) {
+    case "Object":
+    case "Array":
+      return 1;
+    case "Map":
+    case "Set":
+    case "WeakMap":
+    case "WeakSet":
+      return 2;
+    default:
+      return 0;
+  }
+}
+function getTargetType(value) {
+  return value["__v_skip"] || !Object.isExtensible(value) ? 0 : targetTypeMap(toRawType(value));
+}
+function reactive(target) {
+  if (isReadonly(target)) {
+    return target;
+  }
+  return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap);
+}
+function readonly(target) {
+  return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap);
+}
+function createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) {
+  if (!isObject(target)) {
+    return target;
+  }
+  if (target["__v_raw"] && !(isReadonly2 && target["__v_isReactive"])) {
+    return target;
+  }
+  const existingProxy = proxyMap.get(target);
+  if (existingProxy) {
+    return existingProxy;
+  }
+  const targetType = getTargetType(target);
+  if (targetType === 0) {
+    return target;
+  }
+  const proxy = new Proxy(target, targetType === 2 ? collectionHandlers : baseHandlers);
+  proxyMap.set(target, proxy);
+  return proxy;
+}
+function isReadonly(value) {
+  return !!(value && value["__v_isReadonly"]);
+}
+function isShallow(value) {
+  return !!(value && value["__v_isShallow"]);
+}
+function toRaw(observed) {
+  const raw = observed && observed["__v_raw"];
+  return raw ? toRaw(raw) : observed;
+}
+const toReactive = (value) => isObject(value) ? reactive(value) : value;
+const toReadonly = (value) => isObject(value) ? readonly(value) : value;
+function trackRefValue(ref2) {
+  if (shouldTrack && activeEffect) {
+    ref2 = toRaw(ref2);
+    {
+      trackEffects(ref2.dep || (ref2.dep = createDep()));
+    }
+  }
+}
+function triggerRefValue(ref2, newVal) {
+  ref2 = toRaw(ref2);
+  if (ref2.dep) {
+    {
+      triggerEffects(ref2.dep);
+    }
+  }
+}
+function isRef(r) {
+  return !!(r && r.__v_isRef === true);
+}
+function ref(value) {
+  return createRef(value, false);
+}
+function createRef(rawValue, shallow) {
+  if (isRef(rawValue)) {
+    return rawValue;
+  }
+  return new RefImpl(rawValue, shallow);
+}
+class RefImpl {
+  constructor(value, __v_isShallow) {
+    this.__v_isShallow = __v_isShallow;
+    this.dep = void 0;
+    this.__v_isRef = true;
+    this._rawValue = __v_isShallow ? value : toRaw(value);
+    this._value = __v_isShallow ? value : toReactive(value);
+  }
+  get value() {
+    trackRefValue(this);
+    return this._value;
+  }
+  set value(newVal) {
+    const useDirectValue = this.__v_isShallow || isShallow(newVal) || isReadonly(newVal);
+    newVal = useDirectValue ? newVal : toRaw(newVal);
+    if (hasChanged(newVal, this._rawValue)) {
+      this._rawValue = newVal;
+      this._value = useDirectValue ? newVal : toReactive(newVal);
+      triggerRefValue(this);
+    }
+  }
+}
+function callWithErrorHandling(fn, instance, type, args) {
+  let res;
+  try {
+    res = args ? fn(...args) : fn();
+  } catch (err) {
+    handleError(err, instance, type);
+  }
+  return res;
+}
+function callWithAsyncErrorHandling(fn, instance, type, args) {
+  if (isFunction(fn)) {
+    const res = callWithErrorHandling(fn, instance, type, args);
+    if (res && isPromise(res)) {
+      res.catch((err) => {
+        handleError(err, instance, type);
+      });
+    }
+    return res;
+  }
+  const values = [];
+  for (let i = 0; i < fn.length; i++) {
+    values.push(callWithAsyncErrorHandling(fn[i], instance, type, args));
+  }
+  return values;
+}
+function handleError(err, instance, type, throwInDev = true) {
+  const contextVNode = instance ? instance.vnode : null;
+  if (instance) {
+    let cur = instance.parent;
+    const exposedInstance = instance.proxy;
+    const errorInfo = type;
+    while (cur) {
+      const errorCapturedHooks = cur.ec;
+      if (errorCapturedHooks) {
+        for (let i = 0; i < errorCapturedHooks.length; i++) {
+          if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) {
+            return;
+          }
+        }
+      }
+      cur = cur.parent;
+    }
+    const appErrorHandler = instance.appContext.config.errorHandler;
+    if (appErrorHandler) {
+      callWithErrorHandling(appErrorHandler, null, 10, [err, exposedInstance, errorInfo]);
+      return;
+    }
+  }
+  logError(err, type, contextVNode, throwInDev);
+}
+function logError(err, type, contextVNode, throwInDev = true) {
+  {
+    console.error(err);
+  }
+}
+function injectHook(type, hook, target = currentInstance, prepend = false) {
+  if (target) {
+    const hooks = target[type] || (target[type] = []);
+    const wrappedHook = hook.__weh || (hook.__weh = (...args) => {
+      if (target.isUnmounted) {
+        return;
+      }
+      pauseTracking();
+      setCurrentInstance(target);
+      const res = callWithAsyncErrorHandling(hook, target, type, args);
+      unsetCurrentInstance();
+      resetTracking();
+      return res;
+    });
+    if (prepend) {
+      hooks.unshift(wrappedHook);
+    } else {
+      hooks.push(wrappedHook);
+    }
+    return wrappedHook;
+  }
+}
+const createHook = (lifecycle) => (hook, target = currentInstance) => injectHook(lifecycle, hook, target);
+const onMounted = createHook("m");
+const onUnmounted = createHook("um");
+function createAppContext() {
+  return {
+    app: null,
+    config: {
+      isNativeTag: NO,
+      performance: false,
+      globalProperties: {},
+      optionMergeStrategies: {},
+      errorHandler: void 0,
+      warnHandler: void 0,
+      compilerOptions: {}
+    },
+    mixins: [],
+    components: {},
+    directives: {},
+    provides: /* @__PURE__ */ Object.create(null),
+    optionsCache: /* @__PURE__ */ new WeakMap(),
+    propsCache: /* @__PURE__ */ new WeakMap(),
+    emitsCache: /* @__PURE__ */ new WeakMap()
+  };
+}
+createAppContext();
+let currentInstance = null;
+const setCurrentInstance = (instance) => {
+  currentInstance = instance;
+  instance.scope.on();
+};
+const unsetCurrentInstance = () => {
+  currentInstance && currentInstance.scope.off();
+  currentInstance = null;
+};
+function useBlocState(bloc) {
+  const state = ref(bloc.state);
+  const stateSubscription = (newState) => {
+    state.value = newState;
+  };
+  onMounted(() => {
+    bloc.subscribe(stateSubscription);
+  });
+  onUnmounted(() => {
+    bloc.unsubscribe(stateSubscription);
+  });
+  return readonly(state);
+}
 class Bloc {
   constructor(initialState) {
     __publicField(this, "internalState");
@@ -29,4 +784,4 @@ class Bloc {
     }
   }
 }
-export { Bloc };
+export { Bloc, useBlocState };

package/dist/vue-tools.umd.js

@@ -1 +1 @@
-(function(e,t){typeof exports=="object"&&typeof module!="undefined"?t(exports):typeof define=="function"&&define.amd?define(["exports"],t):(e=typeof globalThis!="undefined"?globalThis:e||self,t((e.agendize=e.agendize||{},e.agendize.tools={})))})(this,function(e){"use strict";var o=Object.defineProperty;var l=(e,t,s)=>t in e?o(e,t,{enumerable:!0,configurable:!0,writable:!0,value:s}):e[t]=s;var r=(e,t,s)=>(l(e,typeof t!="symbol"?t+"":t,s),s);class t{constructor(i){r(this,"internalState");r(this,"listeners",[]);this.internalState=i}get state(){return this.internalState}changeState(i){this.internalState=i,this.listeners.length>0&&this.listeners.forEach(n=>n(this.state))}subscribe(i){this.listeners.push(i)}unsubscribe(i){const n=this.listeners.indexOf(i);n>-1&&this.listeners.splice(n,1)}}e.Bloc=t,Object.defineProperties(e,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}})});
+(function(u,l){typeof exports=="object"&&typeof module!="undefined"?l(exports):typeof define=="function"&&define.amd?define(["exports"],l):(u=typeof globalThis!="undefined"?globalThis:u||self,l((u.agendize=u.agendize||{},u.agendize.tools={})))})(this,function(u){"use strict";var ae=Object.defineProperty;var ue=(u,l,b)=>l in u?ae(u,l,{enumerable:!0,configurable:!0,writable:!0,value:b}):u[l]=b;var J=(u,l,b)=>(ue(u,typeof l!="symbol"?l+"":l,b),b);function l(t,e){const n=Object.create(null),r=t.split(",");for(let s=0;s<r.length;s++)n[r[s]]=!0;return e?s=>!!n[s.toLowerCase()]:s=>!!n[s]}const b=()=>!1,mt=Object.prototype.hasOwnProperty,O=(t,e)=>mt.call(t,e),_=Array.isArray,x=t=>Q(t)==="[object Map]",z=t=>typeof t=="function",Et=t=>typeof t=="string",N=t=>typeof t=="symbol",I=t=>t!==null&&typeof t=="object",St=t=>I(t)&&z(t.then)&&z(t.catch),It=Object.prototype.toString,Q=t=>It.call(t),Mt=t=>Q(t).slice(8,-1),B=t=>Et(t)&&t!=="NaN"&&t[0]!=="-"&&""+parseInt(t,10)===t,D=(t,e)=>!Object.is(t,e),G=t=>{const e=new Set(t);return e.w=0,e.n=0,e},Tt=t=>(t.w&Y)>0,Rt=t=>(t.n&Y)>0,V=new WeakMap;let Y=1,M;const m=Symbol(""),$=Symbol("");let T=!0;const X=[];function Z(){X.push(T),T=!1}function k(){const t=X.pop();T=t===void 0?!0:t}function d(t,e,n){if(T&&M){let r=V.get(t);r||V.set(t,r=new Map);let s=r.get(n);s||r.set(n,s=G()),tt(s)}}function tt(t,e){let n=!1;Rt(t)||(t.n|=Y,n=!Tt(t)),n&&(t.add(M),M.deps.push(t))}function g(t,e,n,r,s,o){const i=V.get(t);if(!i)return;let c=[];if(e==="clear")c=[...i.values()];else if(n==="length"&&_(t))i.forEach((f,h)=>{(h==="length"||h>=r)&&c.push(f)});else switch(n!==void 0&&c.push(i.get(n)),e){case"add":_(t)?B(n)&&c.push(i.get("length")):(c.push(i.get(m)),x(t)&&c.push(i.get($)));break;case"delete":_(t)||(c.push(i.get(m)),x(t)&&c.push(i.get($)));break;case"set":x(t)&&c.push(i.get(m));break}if(c.length===1)c[0]&&F(c[0]);else{const f=[];for(const h of c)h&&f.push(...h);F(G(f))}}function F(t,e){const n=_(t)?t:[...t];for(const r of n)r.computed&&et(r);for(const r of n)r.computed||et(r)}function et(t,e){(t!==M||t.allowRecurse)&&(t.scheduler?t.scheduler():t.run())}const Ot=l("__proto__,__v_isRef,__isVue"),nt=new Set(Object.getOwnPropertyNames(Symbol).filter(t=>t!=="arguments"&&t!=="caller").map(t=>Symbol[t]).filter(N)),xt=rt(),jt=rt(!0),st=vt();function vt(){const t={};return["includes","indexOf","lastIndexOf"].forEach(e=>{t[e]=function(...n){const r=a(this);for(let o=0,i=this.length;o<i;o++)d(r,"get",o+"");const s=r[e](...n);return s===-1||s===!1?r[e](...n.map(a)):s}}),["push","pop","shift","unshift","splice"].forEach(e=>{t[e]=function(...n){Z();const r=a(this)[e].apply(this,n);return k(),r}}),t}function rt(t=!1,e=!1){return function(r,s,o){if(s==="__v_isReactive")return!t;if(s==="__v_isReadonly")return t;if(s==="__v_isShallow")return e;if(s==="__v_raw"&&o===(t?e?Ut:lt:e?Ft:ft).get(r))return r;const i=_(r);if(!t&&i&&O(st,s))return Reflect.get(st,s,o);const c=Reflect.get(r,s,o);return(N(s)?nt.has(s):Ot(s))||(t||d(r,"get",s),e)?c:E(c)?i&&B(s)?c:c.value:I(c)?t?L(c):ht(c):c}}const Kt=Pt();function Pt(t=!1){return function(n,r,s,o){let i=n[r];if(W(i)&&E(i)&&!E(s))return!1;if(!t&&(!pt(s)&&!W(s)&&(i=a(i),s=a(s)),!_(n)&&E(i)&&!E(s)))return i.value=s,!0;const c=_(n)&&B(r)?Number(r)<n.length:O(n,r),f=Reflect.set(n,r,s,o);return n===a(o)&&(c?D(s,i)&&g(n,"set",r,s):g(n,"add",r,s)),f}}function Ht(t,e){const n=O(t,e);t[e];const r=Reflect.deleteProperty(t,e);return r&&n&&g(t,"delete",e,void 0),r}function Ct(t,e){const n=Reflect.has(t,e);return(!N(e)||!nt.has(e))&&d(t,"has",e),n}function Wt(t){return d(t,"iterate",_(t)?"length":m),Reflect.ownKeys(t)}const At={get:xt,set:Kt,deleteProperty:Ht,has:Ct,ownKeys:Wt},zt={get:jt,set(t,e){return!0},deleteProperty(t,e){return!0}},U=t=>t,j=t=>Reflect.getPrototypeOf(t);function v(t,e,n=!1,r=!1){t=t.__v_raw;const s=a(t),o=a(e);n||(e!==o&&d(s,"get",e),d(s,"get",o));const{has:i}=j(s),c=r?U:n?q:R;if(i.call(s,e))return c(t.get(e));if(i.call(s,o))return c(t.get(o));t!==s&&t.get(e)}function K(t,e=!1){const n=this.__v_raw,r=a(n),s=a(t);return e||(t!==s&&d(r,"has",t),d(r,"has",s)),t===s?n.has(t):n.has(t)||n.has(s)}function P(t,e=!1){return t=t.__v_raw,!e&&d(a(t),"iterate",m),Reflect.get(t,"size",t)}function ot(t){t=a(t);const e=a(this);return j(e).has.call(e,t)||(e.add(t),g(e,"add",t,t)),this}function it(t,e){e=a(e);const n=a(this),{has:r,get:s}=j(n);let o=r.call(n,t);o||(t=a(t),o=r.call(n,t));const i=s.call(n,t);return n.set(t,e),o?D(e,i)&&g(n,"set",t,e):g(n,"add",t,e),this}function ct(t){const e=a(this),{has:n,get:r}=j(e);let s=n.call(e,t);s||(t=a(t),s=n.call(e,t)),r&&r.call(e,t);const o=e.delete(t);return s&&g(e,"delete",t,void 0),o}function at(){const t=a(this),e=t.size!==0,n=t.clear();return e&&g(t,"clear",void 0,void 0),n}function H(t,e){return function(r,s){const o=this,i=o.__v_raw,c=a(i),f=e?U:t?q:R;return!t&&d(c,"iterate",m),i.forEach((h,p)=>r.call(s,f(h),f(p),o))}}function C(t,e,n){return function(...r){const s=this.__v_raw,o=a(s),i=x(o),c=t==="entries"||t===Symbol.iterator&&i,f=t==="keys"&&i,h=s[t](...r),p=n?U:e?q:R;return!e&&d(o,"iterate",f?$:m),{next(){const{value:A,done:y}=h.next();return y?{value:A,done:y}:{value:c?[p(A[0]),p(A[1])]:p(A),done:y}},[Symbol.iterator](){return this}}}}function w(t){return function(...e){return t==="delete"?!1:this}}function Nt(){const t={get(o){return v(this,o)},get size(){return P(this)},has:K,add:ot,set:it,delete:ct,clear:at,forEach:H(!1,!1)},e={get(o){return v(this,o,!1,!0)},get size(){return P(this)},has:K,add:ot,set:it,delete:ct,clear:at,forEach:H(!1,!0)},n={get(o){return v(this,o,!0)},get size(){return P(this,!0)},has(o){return K.call(this,o,!0)},add:w("add"),set:w("set"),delete:w("delete"),clear:w("clear"),forEach:H(!0,!1)},r={get(o){return v(this,o,!0,!0)},get size(){return P(this,!0)},has(o){return K.call(this,o,!0)},add:w("add"),set:w("set"),delete:w("delete"),clear:w("clear"),forEach:H(!0,!0)};return["keys","values","entries",Symbol.iterator].forEach(o=>{t[o]=C(o,!1,!1),n[o]=C(o,!0,!1),e[o]=C(o,!1,!0),r[o]=C(o,!0,!0)}),[t,n,e,r]}const[Bt,Dt,Gt,Vt]=Nt();function ut(t,e){const n=e?t?Vt:Gt:t?Dt:Bt;return(r,s,o)=>s==="__v_isReactive"?!t:s==="__v_isReadonly"?t:s==="__v_raw"?r:Reflect.get(O(n,s)&&s in r?n:r,s,o)}const Yt={get:ut(!1,!1)},$t={get:ut(!0,!1)},ft=new WeakMap,Ft=new WeakMap,lt=new WeakMap,Ut=new WeakMap;function Lt(t){switch(t){case"Object":case"Array":return 1;case"Map":case"Set":case"WeakMap":case"WeakSet":return 2;default:return 0}}function qt(t){return t.__v_skip||!Object.isExtensible(t)?0:Lt(Mt(t))}function ht(t){return W(t)?t:dt(t,!1,At,Yt,ft)}function L(t){return dt(t,!0,zt,$t,lt)}function dt(t,e,n,r,s){if(!I(t)||t.__v_raw&&!(e&&t.__v_isReactive))return t;const o=s.get(t);if(o)return o;const i=qt(t);if(i===0)return t;const c=new Proxy(t,i===2?r:n);return s.set(t,c),c}function W(t){return!!(t&&t.__v_isReadonly)}function pt(t){return!!(t&&t.__v_isShallow)}function a(t){const e=t&&t.__v_raw;return e?a(e):t}const R=t=>I(t)?ht(t):t,q=t=>I(t)?L(t):t;function yt(t){T&&M&&(t=a(t),tt(t.dep||(t.dep=G())))}function Jt(t,e){t=a(t),t.dep&&F(t.dep)}function E(t){return!!(t&&t.__v_isRef===!0)}function Qt(t){return Xt(t,!1)}function Xt(t,e){return E(t)?t:new Zt(t,e)}class Zt{constructor(e,n){this.__v_isShallow=n,this.dep=void 0,this.__v_isRef=!0,this._rawValue=n?e:a(e),this._value=n?e:R(e)}get value(){return yt(this),this._value}set value(e){const n=this.__v_isShallow||pt(e)||W(e);e=n?e:a(e),D(e,this._rawValue)&&(this._rawValue=e,this._value=n?e:R(e),Jt(this))}}function _t(t,e,n,r){let s;try{s=r?t(...r):t()}catch(o){wt(o,e,n)}return s}function gt(t,e,n,r){if(z(t)){const o=_t(t,e,n,r);return o&&St(o)&&o.catch(i=>{wt(i,e,n)}),o}const s=[];for(let o=0;o<t.length;o++)s.push(gt(t[o],e,n,r));return s}function wt(t,e,n,r=!0){const s=e?e.vnode:null;if(e){let o=e.parent;const i=e.proxy,c=n;for(;o;){const h=o.ec;if(h){for(let p=0;p<h.length;p++)if(h[p](t,i,c)===!1)return}o=o.parent}const f=e.appContext.config.errorHandler;if(f){_t(f,null,10,[t,i,c]);return}}kt(t,n,s,r)}function kt(t,e,n,r=!0){console.error(t)}function te(t,e,n=S,r=!1){if(n){const s=n[t]||(n[t]=[]),o=e.__weh||(e.__weh=(...i)=>{if(n.isUnmounted)return;Z(),re(n);const c=gt(e,n,t,i);return oe(),k(),c});return r?s.unshift(o):s.push(o),o}}const bt=t=>(e,n=S)=>te(t,e,n),ee=bt("m"),ne=bt("um");function se(){return{app:null,config:{isNativeTag:b,performance:!1,globalProperties:{},optionMergeStrategies:{},errorHandler:void 0,warnHandler:void 0,compilerOptions:{}},mixins:[],components:{},directives:{},provides:Object.create(null),optionsCache:new WeakMap,propsCache:new WeakMap,emitsCache:new WeakMap}}se();let S=null;const re=t=>{S=t,t.scope.on()},oe=()=>{S&&S.scope.off(),S=null};function ie(t){const e=Qt(t.state),n=r=>{e.value=r};return ee(()=>{t.subscribe(n)}),ne(()=>{t.unsubscribe(n)}),L(e)}class ce{constructor(e){J(this,"internalState");J(this,"listeners",[]);this.internalState=e}get state(){return this.internalState}changeState(e){this.internalState=e,this.listeners.length>0&&this.listeners.forEach(n=>n(this.state))}subscribe(e){this.listeners.push(e)}unsubscribe(e){const n=this.listeners.indexOf(e);n>-1&&this.listeners.splice(n,1)}}u.Bloc=ce,u.useBlocState=ie,Object.defineProperties(u,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}})});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agendize/vue-tools",
-  "version": "0.0.0",
+  "version": "0.0.1",
   "description": "Agendize tools",
   "private": false,
   "keywords": [