@nil-/xit 0.1.5 → 0.1.7

package/assets/svelte/internal/disclose-version.js

@@ -0,0 +1,2 @@
+const e = "5";
+typeof window < "u" && (window.__svelte || (window.__svelte = { v: /* @__PURE__ */ new Set() })).v.add(e);

package/assets/svelte/motion.js

@@ -0,0 +1,192 @@
+import { w as P } from "./store.js";
+import { linear as z } from "./easing.js";
+const C = requestAnimationFrame, D = () => performance.now(), p = {
+  tick: (
+    /** @param {any} _ */
+    (t) => C(t)
+  ),
+  now: () => D(),
+  tasks: /* @__PURE__ */ new Set()
+};
+function O(t) {
+  p.tasks.forEach((r) => {
+    r.c(t) || (p.tasks.delete(r), r.f());
+  }), p.tasks.size !== 0 && p.tick(O);
+}
+function M(t) {
+  let r;
+  return p.tasks.size === 0 && p.tick(O), {
+    promise: new Promise((e) => {
+      p.tasks.add(r = { c: t, f: e });
+    }),
+    abort() {
+      p.tasks.delete(r);
+    }
+  };
+}
+function h(t) {
+  return Object.prototype.toString.call(t) === "[object Date]";
+}
+function j(t, r, e, i) {
+  if (typeof e == "number" || h(e)) {
+    const n = i - e, s = (e - r) / (t.dt || 1 / 60), o = t.opts.stiffness * n, f = t.opts.damping * s, c = (o - f) * t.inv_mass, l = (s + c) * t.dt;
+    return Math.abs(l) < t.opts.precision && Math.abs(n) < t.opts.precision ? i : (t.settled = !1, h(e) ? new Date(e.getTime() + l) : e + l);
+  } else {
+    if (Array.isArray(e))
+      return e.map(
+        (n, s) => (
+          // @ts-ignore
+          j(t, r[s], e[s], i[s])
+        )
+      );
+    if (typeof e == "object") {
+      const n = {};
+      for (const s in e)
+        n[s] = j(t, r[s], e[s], i[s]);
+      return n;
+    } else
+      throw new Error(`Cannot spring ${typeof e} values`);
+  }
+}
+function q(t, r = {}) {
+  const e = P(t), { stiffness: i = 0.15, damping: n = 0.8, precision: s = 0.01 } = r;
+  let o, f, c, l = (
+    /** @type {T} */
+    t
+  ), y = (
+    /** @type {T | undefined} */
+    t
+  ), a = 1, w = 0, b = !1;
+  function k(u, m = {}) {
+    y = u;
+    const S = c = {};
+    return t == null || m.hard || d.stiffness >= 1 && d.damping >= 1 ? (b = !0, o = p.now(), l = u, e.set(t = y), Promise.resolve()) : (m.soft && (w = 1 / ((m.soft === !0 ? 0.5 : +m.soft) * 60), a = 0), f || (o = p.now(), b = !1, f = M((g) => {
+      if (b)
+        return b = !1, f = null, !1;
+      a = Math.min(a + w, 1);
+      const A = {
+        inv_mass: a,
+        opts: d,
+        settled: !0,
+        dt: (g - o) * 60 / 1e3
+      }, T = j(A, l, t, y);
+      return o = g, l = /** @type {T} */
+      t, e.set(t = /** @type {T} */
+      T), A.settled && (f = null), !A.settled;
+    })), new Promise((g) => {
+      f.promise.then(() => {
+        S === c && g();
+      });
+    }));
+  }
+  const d = {
+    set: k,
+    update: (u, m) => k(u(
+      /** @type {T} */
+      y,
+      /** @type {T} */
+      t
+    ), m),
+    subscribe: e.subscribe,
+    stiffness: i,
+    damping: n,
+    precision: s
+  };
+  return d;
+}
+function E(t, r) {
+  if (t === r || t !== t) return () => t;
+  const e = typeof t;
+  if (e !== typeof r || Array.isArray(t) !== Array.isArray(r))
+    throw new Error("Cannot interpolate values of different type");
+  if (Array.isArray(t)) {
+    const i = (
+      /** @type {Array<any>} */
+      r.map((n, s) => E(
+        /** @type {Array<any>} */
+        t[s],
+        n
+      ))
+    );
+    return (n) => i.map((s) => s(n));
+  }
+  if (e === "object") {
+    if (!t || !r)
+      throw new Error("Object cannot be null");
+    if (h(t) && h(r)) {
+      const s = t.getTime(), f = r.getTime() - s;
+      return (c) => new Date(s + c * f);
+    }
+    const i = Object.keys(r), n = {};
+    return i.forEach((s) => {
+      n[s] = E(t[s], r[s]);
+    }), (s) => {
+      const o = {};
+      return i.forEach((f) => {
+        o[f] = n[f](s);
+      }), o;
+    };
+  }
+  if (e === "number") {
+    const i = (
+      /** @type {number} */
+      r - /** @type {number} */
+      t
+    );
+    return (n) => t + n * i;
+  }
+  throw new Error(`Cannot interpolate ${e} values`);
+}
+function _(t, r = {}) {
+  const e = P(t);
+  let i, n = t;
+  function s(o, f) {
+    if (n = o, t == null)
+      return e.set(t = o), Promise.resolve();
+    let c = i, l = !1, {
+      delay: y = 0,
+      duration: a = 400,
+      easing: w = z,
+      interpolate: b = E
+    } = { ...r, ...f };
+    if (a === 0)
+      return c && (c.abort(), c = null), e.set(t = n), Promise.resolve();
+    const k = p.now() + y;
+    let d;
+    return i = M((u) => {
+      if (u < k) return !0;
+      l || (d = b(
+        /** @type {any} */
+        t,
+        o
+      ), typeof a == "function" && (a = a(
+        /** @type {any} */
+        t,
+        o
+      )), l = !0), c && (c.abort(), c = null);
+      const m = u - k;
+      return m > /** @type {number} */
+      a ? (e.set(t = o), !1) : (e.set(t = d(w(m / a))), !0);
+    }), i.promise;
+  }
+  return {
+    set: s,
+    update: (o, f) => s(o(
+      /** @type {any} */
+      n,
+      /** @type {any} */
+      t
+    ), f),
+    subscribe: e.subscribe
+  };
+}
+const B = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  spring: q,
+  tweened: _
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  B as i,
+  M as l,
+  p as r
+};

package/assets/svelte/store.js

@@ -0,0 +1,161 @@
+import { n as b, u as q, s as x, r as z, a as j, e as A, b as h, c as O, g as B, t as C, d as E } from "./index.js";
+import "./internal/client.js";
+function m(e, t, n) {
+  if (e == null)
+    return t(void 0), n && n(void 0), b;
+  const r = q(
+    () => e.subscribe(
+      t,
+      // @ts-expect-error
+      n
+    )
+  );
+  return r.unsubscribe ? () => r.unsubscribe() : r;
+}
+function M(e) {
+  x(e, e.v + 1);
+}
+const l = [];
+function w(e, t) {
+  return {
+    subscribe: _(e, t).subscribe
+  };
+}
+function _(e, t = b) {
+  let n = null;
+  const r = /* @__PURE__ */ new Set();
+  function u(c) {
+    if (j(e, c) && (e = c, n)) {
+      const f = !l.length;
+      for (const s of r)
+        s[1](), l.push(s, e);
+      if (f) {
+        for (let s = 0; s < l.length; s += 2)
+          l[s][0](l[s + 1]);
+        l.length = 0;
+      }
+    }
+  }
+  function o(c) {
+    u(c(
+      /** @type {T} */
+      e
+    ));
+  }
+  function i(c, f = b) {
+    const s = [c, f];
+    return r.add(s), r.size === 1 && (n = t(u, o) || b), c(
+      /** @type {T} */
+      e
+    ), () => {
+      r.delete(s), r.size === 0 && n && (n(), n = null);
+    };
+  }
+  return { set: u, update: o, subscribe: i };
+}
+function P(e, t, n) {
+  const r = !Array.isArray(e), u = r ? [e] : e;
+  if (!u.every(Boolean))
+    throw new Error("derived() expects stores as input, got a falsy value");
+  const o = t.length < 2;
+  return w(n, (i, c) => {
+    let f = !1;
+    const s = [];
+    let d = 0, p = b;
+    const y = () => {
+      if (d)
+        return;
+      p();
+      const a = t(r ? s[0] : s, i, c);
+      o ? i(a) : p = typeof a == "function" ? a : b;
+    }, v = u.map(
+      (a, g) => m(
+        a,
+        (k) => {
+          s[g] = k, d &= ~(1 << g), f && y();
+        },
+        () => {
+          d |= 1 << g;
+        }
+      )
+    );
+    return f = !0, y(), function() {
+      z(v), p(), f = !1;
+    };
+  });
+}
+function T(e) {
+  return {
+    // @ts-expect-error TODO i suspect the bind is unnecessary
+    subscribe: e.subscribe.bind(e)
+  };
+}
+function S(e) {
+  let t;
+  return m(e, (n) => t = n)(), t;
+}
+function $(e, t) {
+  const n = _(e(), (r) => {
+    let u = !1;
+    const o = A(() => {
+      h(() => {
+        const i = e();
+        u && r(i);
+      });
+    });
+    return u = !0, o;
+  });
+  return t ? {
+    set: t,
+    update: (r) => t(r(e())),
+    subscribe: n.subscribe
+  } : {
+    subscribe: n.subscribe
+  };
+}
+function D(e) {
+  let t, n = E(0), r = 0, u = b;
+  function o() {
+    return O() ? (B(n), h(() => {
+      if (r === 0) {
+        let i = !1;
+        u = e.subscribe((c) => {
+          t = c, i && M(n);
+        }), i = !0;
+      }
+      return r += 1, () => {
+        r -= 1, C().then(() => {
+          r === 0 && u();
+        });
+      };
+    }), t) : S(e);
+  }
+  return "set" in e ? {
+    get current() {
+      return o();
+    },
+    set current(i) {
+      e.set(i);
+    }
+  } : {
+    get current() {
+      return o();
+    }
+  };
+}
+const H = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  derived: P,
+  fromStore: D,
+  get: S,
+  readable: w,
+  readonly: T,
+  toStore: $,
+  writable: _
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  S as g,
+  H as i,
+  m as s,
+  _ as w
+};

package/assets/svelte/transition.js

@@ -0,0 +1,142 @@
+const M = (t) => t;
+function m(t) {
+  const e = t - 1;
+  return e * e * e + 1;
+}
+function C(t) {
+  return t < 0.5 ? 4 * t * t * t : 0.5 * Math.pow(2 * t - 2, 3) + 1;
+}
+function w(t) {
+  const e = typeof t == "string" && t.match(/^\s*(-?[\d.]+)([^\s]*)\s*$/);
+  return e ? [parseFloat(e[1]), e[2] || "px"] : [
+    /** @type {number} */
+    t,
+    "px"
+  ];
+}
+function W(t, { delay: e = 0, duration: a = 400, easing: s = C, amount: p = 5, opacity: n = 0 } = {}) {
+  const c = getComputedStyle(t), r = +c.opacity, d = c.filter === "none" ? "" : c.filter, i = r * (1 - n), [o, y] = w(p);
+  return {
+    delay: e,
+    duration: a,
+    easing: s,
+    css: (f, u) => `opacity: ${r - i * u}; filter: ${d} blur(${u * o}${y});`
+  };
+}
+function q(t, { delay: e = 0, duration: a = 400, easing: s = M } = {}) {
+  const p = +getComputedStyle(t).opacity;
+  return {
+    delay: e,
+    duration: a,
+    easing: s,
+    css: (n) => `opacity: ${n * p}`
+  };
+}
+function B(t, { delay: e = 0, duration: a = 400, easing: s = m, x: p = 0, y: n = 0, opacity: c = 0 } = {}) {
+  const r = getComputedStyle(t), d = +r.opacity, i = r.transform === "none" ? "" : r.transform, o = d * (1 - c), [y, f] = w(p), [u, _] = w(n);
+  return {
+    delay: e,
+    duration: a,
+    easing: s,
+    css: ($, h) => `
+			transform: ${i} translate(${(1 - $) * y}${f}, ${(1 - $) * u}${_});
+			opacity: ${d - o * h}`
+  };
+}
+function L(t, { delay: e = 0, duration: a = 400, easing: s = m, axis: p = "y" } = {}) {
+  const n = getComputedStyle(t), c = +n.opacity, r = p === "y" ? "height" : "width", d = parseFloat(n[r]), i = p === "y" ? ["top", "bottom"] : ["left", "right"], o = i.map(
+    (l) => (
+      /** @type {'Left' | 'Right' | 'Top' | 'Bottom'} */
+      `${l[0].toUpperCase()}${l.slice(1)}`
+    )
+  ), y = parseFloat(n[`padding${o[0]}`]), f = parseFloat(n[`padding${o[1]}`]), u = parseFloat(n[`margin${o[0]}`]), _ = parseFloat(n[`margin${o[1]}`]), $ = parseFloat(
+    n[`border${o[0]}Width`]
+  ), h = parseFloat(
+    n[`border${o[1]}Width`]
+  );
+  return {
+    delay: e,
+    duration: a,
+    easing: s,
+    css: (l) => `overflow: hidden;opacity: ${Math.min(l * 20, 1) * c};${r}: ${l * d}px;padding-${i[0]}: ${l * y}px;padding-${i[1]}: ${l * f}px;margin-${i[0]}: ${l * u}px;margin-${i[1]}: ${l * _}px;border-${i[0]}-width: ${l * $}px;border-${i[1]}-width: ${l * h}px;`
+  };
+}
+function R(t, { delay: e = 0, duration: a = 400, easing: s = m, start: p = 0, opacity: n = 0 } = {}) {
+  const c = getComputedStyle(t), r = +c.opacity, d = c.transform === "none" ? "" : c.transform, i = 1 - p, o = r * (1 - n);
+  return {
+    delay: e,
+    duration: a,
+    easing: s,
+    css: (y, f) => `
+			transform: ${d} scale(${1 - i * f});
+			opacity: ${r - o * f}
+		`
+  };
+}
+function z(t, { delay: e = 0, speed: a, duration: s, easing: p = C } = {}) {
+  let n = t.getTotalLength();
+  const c = getComputedStyle(t);
+  return c.strokeLinecap !== "butt" && (n += parseInt(c.strokeWidth)), s === void 0 ? a === void 0 ? s = 800 : s = n / a : typeof s == "function" && (s = s(n)), {
+    delay: e,
+    duration: s,
+    easing: p,
+    css: (r, d) => `
+			stroke-dasharray: ${n};
+			stroke-dashoffset: ${d * n};
+		`
+  };
+}
+function v(t, e) {
+  for (const a in e) t[a] = e[a];
+  return (
+    /** @type {T & S} */
+    t
+  );
+}
+function I({ fallback: t, ...e }) {
+  const a = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map();
+  function p(c, r, d) {
+    const {
+      delay: i = 0,
+      duration: o = (
+        /** @param {number} d */
+        (g) => Math.sqrt(g) * 30
+      ),
+      easing: y = m
+    } = v(v({}, e), d), f = c.getBoundingClientRect(), u = r.getBoundingClientRect(), _ = f.left - u.left, $ = f.top - u.top, h = f.width / u.width, l = f.height / u.height, k = Math.sqrt(_ * _ + $ * $), x = getComputedStyle(r), F = x.transform === "none" ? "" : x.transform, S = +x.opacity;
+    return {
+      delay: i,
+      duration: typeof o == "function" ? o(k) : o,
+      easing: y,
+      css: (g, b) => `
+			   opacity: ${g * S};
+			   transform-origin: top left;
+			   transform: ${F} translate(${b * _}px,${b * $}px) scale(${g + (1 - g) * h}, ${g + (1 - g) * l});
+		   `
+    };
+  }
+  function n(c, r, d) {
+    return (i, o) => (c.set(o.key, i), () => {
+      if (r.has(o.key)) {
+        const y = r.get(o.key);
+        return r.delete(o.key), p(
+          /** @type {Element} */
+          y,
+          i,
+          o
+        );
+      }
+      return c.delete(o.key), t && t(i, o, d);
+    });
+  }
+  return [n(s, a, !1), n(a, s, !0)];
+}
+export {
+  W as blur,
+  I as crossfade,
+  z as draw,
+  q as fade,
+  B as fly,
+  R as scale,
+  L as slide
+};

package/index.d.ts

@@ -7,16 +7,16 @@ export type Writable<T> = {
     update: (cb: (v: T) => T) => void;
 };
 export type CoDec = {
-    encode: (o: object) => Uint8Array;
-    decode: (a: Uint8Array) => object;
+    encode: (o: Record<string, any>) => Uint8Array;
+    decode: (a: Uint8Array) => Record<string, any>;
 };
 export type FrameInfo = {
     frame: string;
     tag?: string;
 };
 export type Loader = {
-    one: (f: string, tag?: string) => Action<HTMLDivElement>;
-    all: (f: FrameInfo[]) => Action<HTMLDivElement>;
+    one: (f: string, tag?: string) => Promise<Action<HTMLDivElement>>;
+    all: (f: FrameInfo[]) => Promise<Action<HTMLDivElement>>;
 };
 export type Xit = {
     values: {
@@ -25,7 +25,7 @@ export type Xit = {
         number: (t: string, v: number) => Writable<number>;
         string: (t: string, v: string) => Writable<string>;
         buffer: (t: string, v: Uint8Array) => Writable<Uint8Array>;
-        json: (t: string, v: object, codec: CoDec) => Writable<object>;
+        json: <T>(t: string, v: object, codec: CoDec) => Writable<Record<string, any>>;
     };
     signals: {
         none: (t: string) => () => void;
@@ -34,7 +34,7 @@ export type Xit = {
         number: (t: string) => (v: number) => void;
         string: (t: string) => (v: string) => void;
         buffer: (t: string) => (v: Uint8Array) => void;
-        json: (t: string, encoder: CoDec["encode"]) => (v: object) => void;
+        json: <T>(t: string, encoder: CoDec["encode"]) => (v: Record<string, any>) => void;
     };
     loader: Loader;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nil-/xit",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "type": "module",
   "exports": {
     "./package.json": "./package.json",