@jsenv/plugin-toolbar 0.1.1 → 0.1.2

package/dist/js/signals-core.mjs

@@ -0,0 +1,339 @@
+function i() {
+  throw new Error("Cycle detected");
+}
+function t() {
+  if (h > 1) {
+    h--;
+    return;
+  }
+  let i,
+    t = !1;
+  while (void 0 !== o) {
+    let s = o;
+    o = void 0;
+    f++;
+    while (void 0 !== s) {
+      const n = s.o;
+      s.o = void 0;
+      s.f &= -3;
+      if (!(8 & s.f) && v(s)) try {
+        s.c();
+      } catch (s) {
+        if (!t) {
+          i = s;
+          t = !0;
+        }
+      }
+      s = n;
+    }
+  }
+  f = 0;
+  h--;
+  if (t) throw i;
+}
+function s(i) {
+  if (h > 0) return i();
+  h++;
+  try {
+    return i();
+  } finally {
+    t();
+  }
+}
+let n,
+  o,
+  h = 0,
+  f = 0,
+  r = 0;
+function e(i) {
+  if (void 0 === n) return;
+  let t = i.n;
+  if (void 0 === t || t.t !== n) {
+    t = {
+      i: 0,
+      S: i,
+      p: void 0,
+      n: n.s,
+      t: n,
+      e: void 0,
+      x: void 0,
+      r: t
+    };
+    n.s = t;
+    i.n = t;
+    if (32 & n.f) i.S(t);
+    return t;
+  } else if (-1 === t.i) {
+    t.i = 0;
+    if (void 0 !== t.p) {
+      t.p.n = t.n;
+      if (void 0 !== t.n) t.n.p = t.p;
+      t.p = void 0;
+      t.n = n.s;
+      n.s.p = t;
+      n.s = t;
+    }
+    return t;
+  }
+}
+function u(i) {
+  this.v = i;
+  this.i = 0;
+  this.n = void 0;
+  this.t = void 0;
+}
+u.prototype.h = function () {
+  return !0;
+};
+u.prototype.S = function (i) {
+  if (this.t !== i && void 0 === i.e) {
+    i.x = this.t;
+    if (void 0 !== this.t) this.t.e = i;
+    this.t = i;
+  }
+};
+u.prototype.U = function (i) {
+  const t = i.e,
+    s = i.x;
+  if (void 0 !== t) {
+    t.x = s;
+    i.e = void 0;
+  }
+  if (void 0 !== s) {
+    s.e = t;
+    i.x = void 0;
+  }
+  if (i === this.t) this.t = s;
+};
+u.prototype.subscribe = function (i) {
+  const t = this;
+  return b(function () {
+    const s = t.value,
+      n = 32 & this.f;
+    this.f &= -33;
+    try {
+      i(s);
+    } finally {
+      this.f |= n;
+    }
+  });
+};
+u.prototype.valueOf = function () {
+  return this.value;
+};
+u.prototype.toString = function () {
+  return this.value + "";
+};
+u.prototype.peek = function () {
+  return this.v;
+};
+Object.defineProperty(u.prototype, "value", {
+  get() {
+    const i = e(this);
+    if (void 0 !== i) i.i = this.i;
+    return this.v;
+  },
+  set(s) {
+    if (s !== this.v) {
+      if (f > 100) i();
+      this.v = s;
+      this.i++;
+      r++;
+      h++;
+      try {
+        for (let i = this.t; void 0 !== i; i = i.x) i.t.N();
+      } finally {
+        t();
+      }
+    }
+  }
+});
+function c(i) {
+  return new u(i);
+}
+function v(i) {
+  for (let t = i.s; void 0 !== t; t = t.n) if (t.S.i !== t.i || !t.S.h() || t.S.i !== t.i) return !0;
+  return !1;
+}
+function d(i) {
+  for (let t = i.s; void 0 !== t; t = t.n) {
+    const i = t.S.n;
+    if (void 0 !== i) t.r = i;
+    t.S.n = t;
+    t.i = -1;
+  }
+}
+function l(i) {
+  let t,
+    s = i.s;
+  while (void 0 !== s) {
+    const i = s.n;
+    if (-1 === s.i) {
+      s.S.U(s);
+      s.n = void 0;
+    } else {
+      if (void 0 !== t) t.p = s;
+      s.p = void 0;
+      s.n = t;
+      t = s;
+    }
+    s.S.n = s.r;
+    if (void 0 !== s.r) s.r = void 0;
+    s = i;
+  }
+  i.s = t;
+}
+function w(i) {
+  u.call(this, void 0);
+  this.x = i;
+  this.s = void 0;
+  this.g = r - 1;
+  this.f = 4;
+}
+(w.prototype = new u()).h = function () {
+  this.f &= -3;
+  if (1 & this.f) return !1;
+  if (32 == (36 & this.f)) return !0;
+  this.f &= -5;
+  if (this.g === r) return !0;
+  this.g = r;
+  this.f |= 1;
+  if (this.i > 0 && !v(this)) {
+    this.f &= -2;
+    return !0;
+  }
+  const i = n;
+  try {
+    d(this);
+    n = this;
+    const i = this.x();
+    if (16 & this.f || this.v !== i || 0 === this.i) {
+      this.v = i;
+      this.f &= -17;
+      this.i++;
+    }
+  } catch (i) {
+    this.v = i;
+    this.f |= 16;
+    this.i++;
+  }
+  n = i;
+  l(this);
+  this.f &= -2;
+  return !0;
+};
+w.prototype.S = function (i) {
+  if (void 0 === this.t) {
+    this.f |= 36;
+    for (let i = this.s; void 0 !== i; i = i.n) i.S.S(i);
+  }
+  u.prototype.S.call(this, i);
+};
+w.prototype.U = function (i) {
+  u.prototype.U.call(this, i);
+  if (void 0 === this.t) {
+    this.f &= -33;
+    for (let i = this.s; void 0 !== i; i = i.n) i.S.U(i);
+  }
+};
+w.prototype.N = function () {
+  if (!(2 & this.f)) {
+    this.f |= 6;
+    for (let i = this.t; void 0 !== i; i = i.x) i.t.N();
+  }
+};
+w.prototype.peek = function () {
+  if (!this.h()) i();
+  if (16 & this.f) throw this.v;
+  return this.v;
+};
+Object.defineProperty(w.prototype, "value", {
+  get() {
+    if (1 & this.f) i();
+    const t = e(this);
+    this.h();
+    if (void 0 !== t) t.i = this.i;
+    if (16 & this.f) throw this.v;
+    return this.v;
+  }
+});
+function a(i) {
+  return new w(i);
+}
+function y(i) {
+  const s = i.u;
+  i.u = void 0;
+  if ("function" == typeof s) {
+    h++;
+    const o = n;
+    n = void 0;
+    try {
+      s();
+    } catch (t) {
+      i.f &= -2;
+      i.f |= 8;
+      _(i);
+      throw t;
+    } finally {
+      n = o;
+      t();
+    }
+  }
+}
+function _(i) {
+  for (let t = i.s; void 0 !== t; t = t.n) t.S.U(t);
+  i.x = void 0;
+  i.s = void 0;
+  y(i);
+}
+function g(i) {
+  if (n !== this) throw new Error("Out-of-order effect");
+  l(this);
+  n = i;
+  this.f &= -2;
+  if (8 & this.f) _(this);
+  t();
+}
+function p(i) {
+  this.x = i;
+  this.u = void 0;
+  this.s = void 0;
+  this.o = void 0;
+  this.f = 32;
+}
+p.prototype.c = function () {
+  const i = this.S();
+  try {
+    if (!(8 & this.f) && void 0 !== this.x) this.u = this.x();
+  } finally {
+    i();
+  }
+};
+p.prototype.S = function () {
+  if (1 & this.f) i();
+  this.f |= 1;
+  this.f &= -9;
+  y(this);
+  d(this);
+  h++;
+  const t = n;
+  n = this;
+  return g.bind(this, t);
+};
+p.prototype.N = function () {
+  if (!(2 & this.f)) {
+    this.f |= 2;
+    this.o = o;
+    o = this;
+  }
+};
+p.prototype.d = function () {
+  this.f |= 8;
+  if (!(1 & this.f)) _(this);
+};
+function b(i) {
+  const t = new p(i);
+  t.c();
+  return t.d.bind(t);
+}
+export { u as Signal, s as batch, a as computed, b as effect, c as signal };

package/dist/js/signals.mjs

@@ -0,0 +1,202 @@
+import { Component as t, options as i } from "./preact.mjs";
+import { useMemo as e, useRef as n, useEffect as o } from "./hooks.mjs";
+import { Signal as r, computed as f, signal as l, effect as s } from "./signals-core.mjs";
+export { Signal, batch, computed, effect, signal } from "./signals-core.mjs";
+function c(t, e) {
+  i[t] = e.bind(null, i[t] || (() => {}));
+}
+let u, a;
+function d(t) {
+  if (a) a();
+  a = t && t.S();
+}
+function p({
+  data: t
+}) {
+  const i = useSignal(t);
+  i.value = t;
+  const n = e(() => {
+    let t = this.__v;
+    while (t = t.__) if (t.__c) {
+      t.__c.__$f |= 4;
+      break;
+    }
+    this.__$u.c = () => {
+      this.base.data = n.peek();
+    };
+    return f(() => {
+      let t = i.value.value;
+      return 0 === t ? 0 : !0 === t ? "" : t || "";
+    });
+  }, []);
+  return n.value;
+}
+p.displayName = "_st";
+Object.defineProperties(r.prototype, {
+  constructor: {
+    configurable: !0
+  },
+  type: {
+    configurable: !0,
+    value: p
+  },
+  props: {
+    configurable: !0,
+    get() {
+      return {
+        data: this
+      };
+    }
+  },
+  __b: {
+    configurable: !0,
+    value: 1
+  }
+});
+c("__b", (t, i) => {
+  if ("string" == typeof i.type) {
+    let t,
+      e = i.props;
+    for (let n in e) {
+      if ("children" === n) continue;
+      let o = e[n];
+      if (o instanceof r) {
+        if (!t) i.__np = t = {};
+        t[n] = o;
+        e[n] = o.peek();
+      }
+    }
+  }
+  t(i);
+});
+c("__r", (t, i) => {
+  d();
+  let e,
+    n = i.__c;
+  if (n) {
+    n.__$f &= -2;
+    e = n.__$u;
+    if (void 0 === e) n.__$u = e = function (t) {
+      let i;
+      s(function () {
+        i = this;
+      });
+      i.c = () => {
+        n.__$f |= 1;
+        n.setState({});
+      };
+      return i;
+    }();
+  }
+  u = n;
+  d(e);
+  t(i);
+});
+c("__e", (t, i, e, n) => {
+  d();
+  u = void 0;
+  t(i, e, n);
+});
+c("diffed", (t, i) => {
+  d();
+  u = void 0;
+  let e;
+  if ("string" == typeof i.type && (e = i.__e)) {
+    let t = i.__np,
+      n = i.props;
+    if (t) {
+      let i = e.U;
+      if (i) for (let e in i) {
+        let n = i[e];
+        if (void 0 !== n && !(e in t)) {
+          n.d();
+          i[e] = void 0;
+        }
+      } else {
+        i = {};
+        e.U = i;
+      }
+      for (let o in t) {
+        let r = i[o],
+          f = t[o];
+        if (void 0 === r) {
+          r = h(e, o, f, n);
+          i[o] = r;
+        } else r.o(f, n);
+      }
+    }
+  }
+  t(i);
+});
+function h(t, i, e, n) {
+  const o = i in t && void 0 === t.ownerSVGElement,
+    r = l(e);
+  return {
+    o: (t, i) => {
+      r.value = t;
+      n = i;
+    },
+    d: s(() => {
+      const e = r.value.value;
+      if (n[i] !== e) {
+        n[i] = e;
+        if (o) t[i] = e;else if (e) t.setAttribute(i, e);else t.removeAttribute(i);
+      }
+    })
+  };
+}
+c("unmount", (t, i) => {
+  if ("string" == typeof i.type) {
+    let t = i.__e;
+    if (t) {
+      const i = t.U;
+      if (i) {
+        t.U = void 0;
+        for (let t in i) {
+          let e = i[t];
+          if (e) e.d();
+        }
+      }
+    }
+  } else {
+    let t = i.__c;
+    if (t) {
+      const i = t.__$u;
+      if (i) {
+        t.__$u = void 0;
+        i.d();
+      }
+    }
+  }
+  t(i);
+});
+c("__h", (t, i, e, n) => {
+  if (n < 3) i.__$f |= 2;
+  t(i, e, n);
+});
+t.prototype.shouldComponentUpdate = function (t, i) {
+  const e = this.__$u;
+  if (!(e && void 0 !== e.s || 4 & this.__$f)) return !0;
+  if (3 & this.__$f) return !0;
+  for (let t in i) return !0;
+  for (let i in t) if ("__source" !== i && t[i] !== this.props[i]) return !0;
+  for (let i in this.props) if (!(i in t)) return !0;
+  return !1;
+};
+function useSignal(t) {
+  return e(() => l(t), []);
+}
+function useComputed(t) {
+  const i = n(t);
+  i.current = t;
+  u.__$f |= 4;
+  return e(() => f(() => i.current()), []);
+}
+function useSignalEffect(t) {
+  const i = n(t);
+  i.current = t;
+  o(() => s(() => {
+    i.current();
+  }), []);
+}
+export { useComputed, useSignal, useSignalEffect };

package/dist/js/theme_actions.js

@@ -0,0 +1,7 @@
+import { themeSignal } from "./theme_signals.js";
+export const switchToLightTheme = () => {
+  themeSignal.value = "light";
+};
+export const switchToDefaultTheme = () => {
+  themeSignal.value = "dark";
+};

package/dist/js/theme_effects.js

@@ -0,0 +1,6 @@
+import { effect } from "./signals.mjs";
+import { themeSignal } from "./theme_signals.js";
+effect(() => {
+  const theme = themeSignal.value;
+  document.querySelector("html").setAttribute("data-theme", theme);
+});

package/dist/js/theme_signals.js

@@ -0,0 +1,4 @@
+import { signal } from "./signals.mjs";
+import { paramsFromParentWindow } from "./parent_window_context.js";
+import { stateFromLocalStorage } from "./toolbar_state_context.js";
+export const themeSignal = signal(typeof stateFromLocalStorage.theme === "string" ? stateFromLocalStorage.theme : typeof paramsFromParentWindow.theme === "string" ? paramsFromParentWindow.theme : "dark");

package/dist/js/toolbar_animation_setting.js

@@ -0,0 +1,21 @@
+import { effect } from "./signals.mjs";
+import { animationsEnabledSignal } from "./animation_signals.js";
+import { enableAnimations, disableAnimations } from "./animation_actions.js";
+export const renderToolbarAnimationSetting = () => {
+  const animCheckbox = document.querySelector("#toggle_anims");
+  effect(() => {
+    const animationsEnabled = animationsEnabledSignal.value;
+    animCheckbox.checked = animationsEnabled;
+  });
+  animCheckbox.onchange = () => {
+    if (animCheckbox.checked) {
+      enableAnimations();
+    } else {
+      disableAnimations();
+    }
+  };
+  // enable toolbar transition only after first render
+  setTimeout(() => {
+    document.querySelector("#toolbar").setAttribute("data-animate", "");
+  });
+};

package/dist/js/toolbar_autoreload_setting.js

@@ -0,0 +1,67 @@
+import { effect } from "./signals.mjs";
+import { autoreloadEnabledSignal } from "./parent_window_signals.js";
+import { disableAutoreload, enableAutoreload } from "./parent_window_actions.js";
+export const renderToolbarAutoreloadSetting = () => {
+  const parentWindowReloader = window.parent.__reloader__;
+  if (!parentWindowReloader) {
+    disableAutoreloadSetting();
+    return;
+  }
+  const autoreloadCheckbox = document.querySelector("#toggle_autoreload");
+  effect(() => {
+    const autoreloadEnabled = autoreloadEnabledSignal.value;
+    if (autoreloadEnabled) {
+      autoreloadCheckbox.checked = true;
+    } else {
+      autoreloadCheckbox.checked = false;
+    }
+  });
+  autoreloadCheckbox.onchange = () => {
+    if (autoreloadCheckbox.checked) {
+      enableAutoreload();
+    } else {
+      disableAutoreload();
+    }
+  };
+};
+const disableAutoreloadSetting = () => {
+  document.querySelector(".settings_autoreload").setAttribute("data-disabled", "true");
+  document.querySelector(".settings_autoreload").setAttribute("title", `Autoreload not enabled on server`);
+  document.querySelector("#toggle_autoreload").disabled = true;
+};
+
+// const changeLink = variantNode.querySelector(".eventsource-changes-link")
+// changeLink.innerHTML = reloadMessageCount
+// changeLink.onclick = () => {
+//   console.log(reloadMessages)
+//   // eslint-disable-next-line no-alert
+//   window.parent.alert(JSON.stringify(reloadMessages, null, "  "))
+// }
+
+// const someFailed = reloadMessages.some((m) => m.status === "failed")
+// const somePending = reloadMessages.some((m) => m.status === "pending")
+// const applyLink = variantNode.querySelector(".eventsource-reload-link")
+// applyLink.innerHTML = someFailed
+//   ? "failed"
+//   : somePending
+//   ? "applying..."
+//   : "apply changes"
+// applyLink.onclick = someFailed
+//   ? () => {
+//       parentEventSourceClient.applyReloadMessageEffects()
+//     }
+//   : somePending
+//   ? () => {}
+//   : () => {
+//       parentEventSourceClient.applyReloadMessageEffects()
+//     }
+
+// parentEventSourceClient.reloadMessagesSignal.onchange = () => {
+//   updateEventSourceIndicator()
+// }
+// const autoreloadCheckbox = document.querySelector("#toggle-autoreload")
+// autoreloadCheckbox.checked = parentEventSourceClient.isAutoreloadEnabled()
+// autoreloadCheckbox.onchange = () => {
+//   parentEventSourceClient.setAutoreloadPreference(autoreloadCheckbox.checked)
+//   updateEventSourceIndicator()
+// }

package/dist/js/toolbar_close_button.js

@@ -0,0 +1,14 @@
+import { openedSignal } from "./toolbar_open_signals.js";
+import { openToolbar, closeToolbar } from "./toolbar_open_actions.js";
+export const renderToolbarCloseButton = () => {
+  // if user click enter or space quickly while closing toolbar
+  // it will cancel the closing
+  // that's why I used toggleToolbar and not hideToolbar
+  document.querySelector("#toolbar_close_button").onclick = () => {
+    if (openedSignal.value) {
+      closeToolbar();
+    } else {
+      openToolbar();
+    }
+  };
+};