@mkbabb/glass-ui 3.13.0 → 4.0.1

package/dist/{dockContext-BegmJVmx.js → dockContext-BNfyPLe9.js}

@@ -1,4 +1,4 @@
-import { n as e } from "./createContext-BM46COQ-.js";
+import { n as e } from "./createContext-CpBNTRMI.js";
 //#region src/components/custom/dock/constants.ts
 var t = {
 	response: .32,

package/dist/dom.js

@@ -1,6 +1,6 @@
-import { t as e } from "./useResizeObserver-BhgdhOIj.js";
-import { t } from "./useTouchGate-Dg7MQI1G.js";
-import { a as n, i as r, n as i, o as a, r as o, t as s } from "./useViewportReady-B40FK4Pa.js";
-import { n as c, t as l } from "./useResolveTokenColor-Dvn2RZJW.js";
-import { t as u } from "./useUserInvalidAria-B2h6jAM_.js";
+import { t as e } from "./useResizeObserver-Bpoi7tRE.js";
+import { t } from "./useTouchGate-CBZTD4SD.js";
+import { a as n, i as r, n as i, o as a, r as o, t as s } from "./useViewportReady-anbac3m6.js";
+import { n as c, t as l } from "./useResolveTokenColor-vAylyR0x.js";
+import { t as u } from "./useUserInvalidAria-y5namzeE.js";
 export { r as copyToClipboard, l as createTokenColorCache, c as resolveTokenColor, o as useBreakpoint, n as useClipboard, i as useIdleReady, e as useResizeObserver, a as useTokenColor, t as useTouchGate, u as useUserInvalidAria, s as useViewportReady };

package/dist/dot-flow-field.d.ts

@@ -0,0 +1 @@
+export * from "./components/custom/dot-flow-field";

package/dist/dot-flow-field.js

@@ -0,0 +1,604 @@
+import { t as e } from "./useCanvas2D-B8w_E3Rr.js";
+import { t } from "./_plugin-vue_export-helper-C1je1s0u.js";
+import { a as n, n as r, o as i, r as a, u as o } from "./procedural-color.wgsl-CToRHugY.js";
+import { c as s, o as c } from "./color-DweYl7pE.js";
+import { computed as l, createElementBlock as u, createElementVNode as d, defineComponent as f, normalizeStyle as p, onScopeDispose as m, openBlock as h, useTemplateRef as g, watch as _ } from "vue";
+//#region src/components/custom/dot-flow-field/shaders/flow-field.compute.wgsl.ts
+var v = "\nconst MAX_WAVE_COMPONENTS: i32 = 8;\nconst PI: f32 = 3.141592653589793;\nconst TAU: f32 = 6.283185307179586;\nconst FLOW_GRAVITY: f32 = 9.81;\nconst CURL_EPS: f32 = 0.012;\nconst FBM_ROT: mat2x2<f32> = mat2x2<f32>(0.8, 0.6, -0.6, 0.8);\n\nstruct Particle {\n  // (pos.x, pos.y, age, seed)\n  data: vec4<f32>,\n};\n\n// ── Uniforms (the typed-struct source-of-truth — see uniformBridgeWGPU.ts) ──\nstruct FlowUniforms {\n  // p0: (uTime, uDt, uWindSpeed, uCurlStrength)\n  p0: vec4<f32>,\n  // p1: (uDomainHalf, uReseedJitter, _pad, _pad)\n  p1: vec4<f32>,\n  // ints: (uWaveCount, uParticleCount, _pad, _pad)\n  ints: vec4<i32>,\n  // each wave row: (amplitude, wavelength, directionDeg, phase)\n  waves: array<vec4<f32>, 8>,\n};\n\n@group(0) @binding(0) var<uniform> u: FlowUniforms;\n@group(0) @binding(1) var<storage, read_write> particles: array<Particle>;\n\n// ── The Gerstner-sum analytic ∇⊥h velocity (transcribes flowField.ts gerstnerVelocity) ──\nfn gerstnerVelocity(p: vec2<f32>, t: f32) -> vec2<f32> {\n  var dhdx = 0.0;\n  var dhdy = 0.0;\n  let windSpeed = u.p0.z;\n  let waveCount = u.ints.x;\n  for (var i = 0; i < MAX_WAVE_COMPONENTS; i = i + 1) {\n    if (i >= waveCount) { break; }\n    let w = u.waves[i];\n    let amplitude = w.x;\n    let wavelength = max(w.y, 1e-4);\n    let dirRad = w.z * PI / 180.0;\n    let phase = w.w;\n    let k = TAU / wavelength;\n    let d = vec2<f32>(cos(dirRad), sin(dirRad));\n    let omega = sqrt(FLOW_GRAVITY * k) * windSpeed;\n    let theta = k * (d.x * p.x + d.y * p.y) - omega * t + phase;\n    let akc = amplitude * k * cos(theta);\n    dhdx = dhdx + akc * d.x;\n    dhdy = dhdy + akc * d.y;\n  }\n  // v = ∇⊥h = (∂h/∂y, −∂h/∂x).\n  return vec2<f32>(dhdy, -dhdx);\n}\n\n// ── Shared curl-noise basis (the WGSL twin of flow.glsl.ts curlFBM) ──\nfn hash21(p: vec2<f32>) -> f32 {\n  var p3 = fract(vec3<f32>(p.x, p.y, p.x) * 0.1031);\n  p3 = p3 + dot(p3, p3.yzx + 33.33);\n  return fract((p3.x + p3.y) * p3.z);\n}\n\nfn valueNoise(p: vec2<f32>) -> f32 {\n  let i = floor(p);\n  let f = fract(p);\n  let u2 = f * f * f * (f * (f * 6.0 - 15.0) + 10.0);\n  let a = hash21(i + vec2<f32>(0.0, 0.0));\n  let b = hash21(i + vec2<f32>(1.0, 0.0));\n  let c = hash21(i + vec2<f32>(0.0, 1.0));\n  let d = hash21(i + vec2<f32>(1.0, 1.0));\n  return mix(mix(a, b, u2.x), mix(c, d, u2.x), u2.y);\n}\n\nfn potentialFBM(p0: vec2<f32>) -> f32 {\n  var v = 0.0;\n  var amp = 0.5;\n  var freq = 1.0;\n  var p = p0;\n  for (var i = 0; i < 3; i = i + 1) {\n    v = v + amp * valueNoise(p * freq);\n    p = FBM_ROT * p;\n    freq = freq * 2.0;\n    amp = amp * 0.5;\n  }\n  return v;\n}\n\nfn curlFBM(p: vec2<f32>) -> vec2<f32> {\n  let dx = potentialFBM(p + vec2<f32>(CURL_EPS, 0.0)) - potentialFBM(p - vec2<f32>(CURL_EPS, 0.0));\n  let dy = potentialFBM(p + vec2<f32>(0.0, CURL_EPS)) - potentialFBM(p - vec2<f32>(0.0, CURL_EPS));\n  let g = vec2<f32>(dx, dy) / (2.0 * CURL_EPS);\n  return vec2<f32>(g.y, -g.x);\n}\n\n// The composite flow velocity (transcribes flowField.ts sampleVelocity EXACTLY).\nfn sampleVelocity(p: vec2<f32>, t: f32) -> vec2<f32> {\n  let curlStrength = u.p0.w;\n  var v = gerstnerVelocity(p, t);\n  if (curlStrength > 0.0) {\n    let c = curlFBM(vec2<f32>(p.x * 1.7 + t * 0.15, p.y * 1.7));\n    v = v + c * curlStrength;\n  }\n  return v;\n}\n\n// A particle that leaves the bounds re-spawns at a seed-derived position (so coverage\n// stays steady — the §3 re-seed-at-edge rule). The seed advances each re-spawn so a\n// re-seeded particle does not pile on the previous spawn.\nfn reseed(seed: f32, age: f32) -> vec2<f32> {\n  let half = u.p1.x;\n  let r1 = hash21(vec2<f32>(seed * 71.13, age * 13.7));\n  let r2 = hash21(vec2<f32>(seed * 19.31 + 4.0, age * 7.3 + 2.0));\n  return (vec2<f32>(r1, r2) * 2.0 - 1.0) * half;\n}\n\n@compute @workgroup_size(64)\nfn cs_main(@builtin(global_invocation_id) gid: vec3<u32>) {\n  let idx = gid.x;\n  let count = u32(u.ints.y);\n  if (idx >= count) { return; } // bounds-guard the dispatch tail\n\n  let t = u.p0.x;\n  let dt = u.p0.y;\n  let half = u.p1.x;\n\n  var pr = particles[idx];\n  var pos = pr.data.xy;\n  var age = pr.data.z;\n  let seed = pr.data.w;\n\n  let v = sampleVelocity(pos, t);\n  // Forward Euler — p_{n+1} = p_n + v·dt.\n  pos = pos + v * dt;\n  age = age + dt;\n\n  // Wrap / re-seed at the domain edge (re-spawn from the seed at a fresh position).\n  if (abs(pos.x) > half || abs(pos.y) > half || age > 6.0) {\n    pos = reseed(seed, age);\n    age = 0.0;\n  }\n\n  particles[idx] = Particle(vec4<f32>(pos, age, seed));\n}\n", y = `
+const PI: f32 = 3.141592653589793;
+const TAU: f32 = 6.283185307179586;
+const FLOW_GRAVITY: f32 = 9.81;
+const MAX_WAVE_COMPONENTS: i32 = 8;
+const MAX_FLOW_STOPS: i32 = 4;
+
+struct Particle {
+  // (pos.x, pos.y, age, seed)
+  data: vec4<f32>,
+};
+
+// ── Render uniforms (the typed-struct source-of-truth — see uniformBridgeWGPU.ts) ──
+struct RenderUniforms {
+  // r0: (uTime, uWindSpeed, uCurlStrength, uDomainHalf)
+  r0: vec4<f32>,
+  // r1: (uDotSize, uDotSizeVelocity, uAspect, uVMax)
+  r1: vec4<f32>,
+  // ints: (uWaveCount, uStopCount, uParticleCount, _pad)
+  ints: vec4<i32>,
+  // bg: (background.rgb, hasBackground)
+  bg: vec4<f32>,
+  // each wave row: (amplitude, wavelength, directionDeg, phase)
+  waves: array<vec4<f32>, 8>,
+  // each palette stop: linear-sRGB rgb + _pad
+  palette: array<vec4<f32>, 4>,
+};
+
+@group(0) @binding(0) var<uniform> u: RenderUniforms;
+@group(0) @binding(1) var<storage, read> particles: array<Particle>;
+
+${r}
+${a}
+
+// ── The Gerstner-sum velocity (the SAME transcription as the compute kernel, read here
+//    for the per-particle size + color tint — denser-where-calm). ──
+fn gerstnerVelocity(p: vec2<f32>, t: f32) -> vec2<f32> {
+  var dhdx = 0.0;
+  var dhdy = 0.0;
+  let windSpeed = u.r0.y;
+  let waveCount = u.ints.x;
+  for (var i = 0; i < MAX_WAVE_COMPONENTS; i = i + 1) {
+    if (i >= waveCount) { break; }
+    let w = u.waves[i];
+    let k = TAU / max(w.y, 1e-4);
+    let dirRad = w.z * PI / 180.0;
+    let d = vec2<f32>(cos(dirRad), sin(dirRad));
+    let omega = sqrt(FLOW_GRAVITY * k) * windSpeed;
+    let theta = k * (d.x * p.x + d.y * p.y) - omega * t + w.w;
+    let akc = w.x * k * cos(theta);
+    dhdx = dhdx + akc * d.x;
+    dhdy = dhdy + akc * d.y;
+  }
+  return vec2<f32>(dhdy, -dhdx);
+}
+
+// Sample the multi-stop palette (linear-sRGB stops, OKLab mix). t in [0,1].
+fn samplePaletteLin(t: f32) -> vec3<f32> {
+  let stopCount = u.ints.y;
+  if (stopCount <= 1) { return u.palette[0].rgb; }
+  let n = f32(stopCount);
+  let ft = clamp(t, 0.0, 1.0) * (n - 1.0);
+  let i0 = i32(floor(ft));
+  let i1 = min(i0 + 1, stopCount - 1);
+  let f = ft - f32(i0);
+  let labA = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * u.palette[i0].rgb);
+  let labB = LMS_TO_OKLAB * cbrt3(LINEAR_SRGB_TO_LMS * u.palette[i1].rgb);
+  return oklabToLinearSrgb(mix(labA, labB, f));
+}
+
+struct VSOut {
+  @builtin(position) pos: vec4<f32>,
+  @location(0) local: vec2<f32>,   // [-1,1] billboard-local coords for the soft circle
+  @location(1) tint: f32,          // velocity-derived color/alpha tint [0,1]
+  @location(2) alphaScale: f32,    // velocity-derived alpha scale (denser-where-calm)
+};
+
+@vertex
+fn vs_main(
+  @builtin(vertex_index) vi: u32,
+  @builtin(instance_index) ii: u32,
+) -> VSOut {
+  // Two-triangle quad corners in billboard-local space.
+  var corners = array<vec2<f32>, 6>(
+    vec2<f32>(-1.0, -1.0), vec2<f32>(1.0, -1.0), vec2<f32>(-1.0, 1.0),
+    vec2<f32>(-1.0, 1.0), vec2<f32>(1.0, -1.0), vec2<f32>(1.0, 1.0),
+  );
+  let local = corners[vi];
+
+  let pr = particles[ii].data;
+  let p = pr.xy;
+  let t = u.r0.x;
+  let half = u.r0.w;
+
+  // Per-particle velocity → size + tint (denser-where-calm: |v| thins the dot).
+  let v = gerstnerVelocity(p, t);
+  let speed = length(v);
+  let vMax = max(u.r1.w, 1e-4);
+  let speedNorm = clamp(speed / vMax, 0.0, 1.0);
+  let dotSizeVel = u.r1.y;
+  // size_i = base · (1 − speedNorm · sizeVel) — calm = larger dot.
+  let sizeWorld = u.r1.x * (1.0 - speedNorm * dotSizeVel);
+  let alphaScale = 1.0 - speedNorm * 0.35; // calm = denser/brighter
+
+  // Position the quad at the particle in clip space. Domain [-half,half] → NDC [-1,1];
+  // the quad half-extent rides sizeWorld (in the same domain units, aspect-corrected x).
+  let aspect = u.r1.z;
+  let ndc = p / half;
+  let off = local * sizeWorld / half;
+  let offX = off.x / max(aspect, 1e-4);
+
+  var out: VSOut;
+  out.pos = vec4<f32>(ndc.x + offX, ndc.y + off.y, 0.0, 1.0);
+  out.local = local;
+  out.tint = speedNorm;
+  out.alphaScale = alphaScale;
+  return out;
+}
+
+@fragment
+fn fs_main(in: VSOut) -> @location(0) vec4<f32> {
+  // Soft circle — radial smoothstep over the billboard-local radius.
+  let r = length(in.local);
+  let feather = 0.35;
+  let mask = 1.0 - smoothstep(1.0 - feather, 1.0, r);
+  if (mask < 0.002) { return vec4<f32>(0.0); }
+
+  let lin = samplePaletteLin(in.tint);
+  let alpha = mask * in.alphaScale;
+  let rgb = clamp(linearToSrgb(lin), vec3<f32>(0.0), vec3<f32>(1.0));
+  // Premultiplied-alpha output.
+  return vec4<f32>(rgb * alpha, alpha);
+}
+`, b = 9.81, x = Math.PI * 2;
+function S(e) {
+	let t = e * Math.PI / 180;
+	return {
+		x: Math.cos(t),
+		y: Math.sin(t)
+	};
+}
+function C(e, t, n, r) {
+	let i = 0, a = 0;
+	for (let o of n) {
+		let n = x / Math.max(o.wavelength, 1e-4), s = S(o.direction), c = Math.sqrt(b * n) * r, l = n * (s.x * e.x + s.y * e.y) - c * t + o.phase, u = Math.cos(l), d = o.amplitude * n * u;
+		i += d * s.x, a += d * s.y;
+	}
+	return {
+		x: a,
+		y: -i
+	};
+}
+var w = .012;
+function T(e, t) {
+	let n = e * .1031 % 1, r = t * .1031 % 1, i = e * .1031 % 1;
+	n < 0 && (n += 1), r < 0 && (r += 1), i < 0 && (i += 1);
+	let a = n * (r + 33.33) + r * (i + 33.33) + i * (n + 33.33);
+	n += a, r += a, i += a;
+	let o = (n + r) * i % 1;
+	return o < 0 && (o += 1), o;
+}
+function E(e, t, n) {
+	return e + (t - e) * n;
+}
+function D(e, t) {
+	let n = Math.floor(e), r = Math.floor(t), i = e - n, a = t - r, o = i * i * i * (i * (i * 6 - 15) + 10), s = a * a * a * (a * (a * 6 - 15) + 10), c = T(n, r), l = T(n + 1, r), u = T(n, r + 1), d = T(n + 1, r + 1);
+	return E(E(c, l, o), E(u, d, o), s);
+}
+function O(e, t) {
+	let n = 0, r = .5, i = 1, a = e, o = t;
+	for (let e = 0; e < 3; e++) {
+		n += r * D(a * i, o * i);
+		let e = .8 * a - .6 * o, t = .6 * a + .8 * o;
+		a = e, o = t, i *= 2, r *= .5;
+	}
+	return n;
+}
+function k(e) {
+	let t = O(e.x + w, e.y) - O(e.x - w, e.y), n = O(e.x, e.y + w) - O(e.x, e.y - w), r = t / (2 * w);
+	return {
+		x: n / (2 * w),
+		y: -r
+	};
+}
+function A(e, t, n, r, i) {
+	let a = C(e, t, n, r);
+	if (i <= 0) return a;
+	let o = k({
+		x: e.x * 1.7 + t * .15,
+		y: e.y * 1.7
+	});
+	return {
+		x: a.x + o.x * i,
+		y: a.y + o.y * i
+	};
+}
+function j(e, t = 6) {
+	let n = [], r = 2.4;
+	for (let i = 0; i < t; i++) {
+		let t = x / r, a = Math.exp(-1 / (t * 1.6) ** 2) / (t * t), o = (i % 2 == 0 ? 1 : -1) * (18 + i * 9);
+		n.push({
+			amplitude: a * .5,
+			wavelength: r,
+			direction: e + o,
+			phase: i * 1.618033 % x
+		}), r *= .62;
+	}
+	return n;
+}
+//#endregion
+//#region src/components/custom/dot-flow-field/constants.ts
+var M = 16384, N = 8, P = 4, F = 4e3, I = [{
+	L: .92,
+	C: .03,
+	h: 78
+}, {
+	L: .84,
+	C: .07,
+	h: 62
+}], L = j(35, 6), R = {
+	particleCount: F,
+	waveComponents: L,
+	windDirection: 35,
+	windSpeed: 1,
+	curlStrength: .6,
+	dotSize: 2.4,
+	dotSizeVelocity: .5,
+	palette: I,
+	background: "transparent",
+	interactive: !1,
+	respectReducedMotion: !0
+}, z = 176, B = {
+	p0: 0,
+	p1: 4,
+	ints: 8,
+	waves: 12
+};
+function V() {
+	let e = new ArrayBuffer(z);
+	return {
+		buffer: e,
+		f32: new Float32Array(e),
+		i32: new Int32Array(e)
+	};
+}
+var H = .85;
+function U(e, t, n, r, i) {
+	let { f32: a, i32: o } = e;
+	a[B.p0 + 0] = n, a[B.p0 + 1] = r, a[B.p0 + 2] = t.windSpeed, a[B.p0 + 3] = t.curlStrength, a[B.p1 + 0] = H, a[B.p1 + 1] = 0, a[B.p1 + 2] = 0, a[B.p1 + 3] = 0;
+	let s = Math.min(t.waveComponents.length, 8);
+	return o[B.ints + 0] = s, o[B.ints + 1] = i, o[B.ints + 2] = 0, o[B.ints + 3] = 0, q(a, B.waves, t.waveComponents), e;
+}
+var W = 256, G = {
+	r0: 0,
+	r1: 4,
+	ints: 8,
+	bg: 12,
+	waves: 16,
+	palette: 48
+};
+function K() {
+	let e = new ArrayBuffer(W);
+	return {
+		buffer: e,
+		f32: new Float32Array(e),
+		i32: new Int32Array(e)
+	};
+}
+function ee(e, t) {
+	let n = t / (2 * H);
+	return e / Math.max(n, 1e-4);
+}
+function te(e, t, n, r, i, a) {
+	let { f32: o, i32: c } = e;
+	o[G.r0 + 0] = n, o[G.r0 + 1] = t.windSpeed, o[G.r0 + 2] = t.curlStrength, o[G.r0 + 3] = H, o[G.r1 + 0] = ee(t.dotSize, i), o[G.r1 + 1] = t.dotSizeVelocity, o[G.r1 + 2] = r, o[G.r1 + 3] = 2;
+	let l = Math.min(t.waveComponents.length, 8), u = Math.min(a.length, 4);
+	if (c[G.ints + 0] = l, c[G.ints + 1] = u, c[G.ints + 2] = t.particleCount, c[G.ints + 3] = 0, t.background === "transparent") o[G.bg + 0] = 0, o[G.bg + 1] = 0, o[G.bg + 2] = 0, o[G.bg + 3] = 0;
+	else {
+		let e = s(t.background);
+		o[G.bg + 0] = e[0], o[G.bg + 1] = e[1], o[G.bg + 2] = e[2], o[G.bg + 3] = 1;
+	}
+	q(o, G.waves, t.waveComponents);
+	for (let e = 0; e < 4; e++) {
+		let t = G.palette + e * 4, n = s(a[Math.min(e, u - 1)] ?? a[0]);
+		o[t + 0] = n[0], o[t + 1] = n[1], o[t + 2] = n[2], o[t + 3] = 0;
+	}
+	return e;
+}
+function q(e, t, n) {
+	for (let r = 0; r < 8; r++) {
+		let i = t + r * 4, a = n[r];
+		a ? (e[i + 0] = a.amplitude, e[i + 1] = a.wavelength, e[i + 2] = a.direction, e[i + 3] = a.phase) : (e[i + 0] = 0, e[i + 1] = 1, e[i + 2] = 0, e[i + 3] = 0);
+	}
+}
+function ne(e) {
+	let t = new Float32Array(e * 4);
+	for (let n = 0; n < e; n++) {
+		let e = (n + 1) * .6180339887, r = Math.sin(e * 71.13) * 43758.5453;
+		r -= Math.floor(r);
+		let i = Math.sin(e * 19.31 + 4) * 43758.5453;
+		i -= Math.floor(i);
+		let a = n * 4;
+		t[a + 0] = (r * 2 - 1) * H, t[a + 1] = (i * 2 - 1) * H, t[a + 2] = r * 6 % 6, t[a + 3] = e;
+	}
+	return t;
+}
+//#endregion
+//#region src/components/custom/dot-flow-field/composables/useFlowParticles.ts
+var J = 64, re = 128, Y = 8, X = 1, ie = 2, Z = 4, ae = 64;
+function oe(e) {
+	let { canvas: t, config: n, getPalette: r, shouldContinue: i } = e;
+	return function(e, a, s) {
+		let c = Math.min(Math.max(n.particleCount, 1), M), l = e.createShaderModule({
+			label: "[DotFlowField] flow-field.compute.wgsl",
+			code: v
+		}), u = e.createShaderModule({
+			label: "[DotFlowField] flow-field.render.wgsl",
+			code: y
+		}), d = ne(c), f = e.createBuffer({
+			label: "[DotFlowField] particles",
+			size: c * 16,
+			usage: re | Y,
+			mappedAtCreation: !0
+		});
+		new Float32Array(f.getMappedRange()).set(d), f.unmap();
+		let p = e.createBuffer({
+			label: "[DotFlowField] compute-uniforms",
+			size: V().buffer.byteLength,
+			usage: J | Y
+		}), m = e.createBuffer({
+			label: "[DotFlowField] render-uniforms",
+			size: K().buffer.byteLength,
+			usage: J | Y
+		}), h = e.createBindGroupLayout({
+			label: "[DotFlowField] compute-bgl",
+			entries: [{
+				binding: 0,
+				visibility: Z,
+				buffer: { type: "uniform" }
+			}, {
+				binding: 1,
+				visibility: Z,
+				buffer: { type: "storage" }
+			}]
+		}), g = e.createComputePipeline({
+			label: "[DotFlowField] compute-pipeline",
+			layout: e.createPipelineLayout({ bindGroupLayouts: [h] }),
+			compute: {
+				module: l,
+				entryPoint: "cs_main"
+			}
+		}), _ = e.createBindGroup({
+			label: "[DotFlowField] compute-bg",
+			layout: h,
+			entries: [{
+				binding: 0,
+				resource: { buffer: p }
+			}, {
+				binding: 1,
+				resource: { buffer: f }
+			}]
+		}), b = e.createBindGroupLayout({
+			label: "[DotFlowField] render-bgl",
+			entries: [{
+				binding: 0,
+				visibility: X | ie,
+				buffer: { type: "uniform" }
+			}, {
+				binding: 1,
+				visibility: X,
+				buffer: { type: "read-only-storage" }
+			}]
+		}), x = e.createRenderPipeline({
+			label: "[DotFlowField] render-pipeline",
+			layout: e.createPipelineLayout({ bindGroupLayouts: [b] }),
+			vertex: {
+				module: u,
+				entryPoint: "vs_main"
+			},
+			fragment: {
+				module: u,
+				entryPoint: "fs_main",
+				targets: [{
+					format: s,
+					blend: {
+						color: {
+							srcFactor: "one",
+							dstFactor: "one-minus-src-alpha",
+							operation: "add"
+						},
+						alpha: {
+							srcFactor: "one",
+							dstFactor: "one-minus-src-alpha",
+							operation: "add"
+						}
+					}
+				}]
+			},
+			primitive: { topology: "triangle-list" }
+		}), S = e.createBindGroup({
+			label: "[DotFlowField] render-bg",
+			layout: b,
+			entries: [{
+				binding: 0,
+				resource: { buffer: m }
+			}, {
+				binding: 1,
+				resource: { buffer: f }
+			}]
+		}), C = V(), w = K(), T = -1, E = Math.ceil(c / ae);
+		function D() {
+			let e = o(), n = t.clientWidth || 320, r = t.clientHeight || 320, i = Math.max(1, Math.round(n * e)), a = Math.max(1, Math.round(r * e));
+			(t.width !== i || t.height !== a) && (t.width = i, t.height = a);
+		}
+		function O(i) {
+			let o = T < 0 ? 0 : Math.min(Math.max(i - T, 0), .05);
+			T = i;
+			let s = Math.min(t.clientWidth || 320, t.clientHeight || 320), l = (t.clientWidth || 320) / Math.max(t.clientHeight || 320, 1);
+			U(C, n, i, o, c), e.queue.writeBuffer(p, 0, C.buffer), te(w, n, i, l, s, r()), e.queue.writeBuffer(m, 0, w.buffer);
+			let u = e.createCommandEncoder({ label: "[DotFlowField] frame" }), d = u.beginComputePass();
+			d.setPipeline(g), d.setBindGroup(0, _), d.dispatchWorkgroups(E), d.end();
+			let f = a.getCurrentTexture().createView(), h = u.beginRenderPass({ colorAttachments: [{
+				view: f,
+				clearValue: {
+					r: 0,
+					g: 0,
+					b: 0,
+					a: 0
+				},
+				loadOp: "clear",
+				storeOp: "store"
+			}] });
+			h.setPipeline(x), h.setBindGroup(0, S), h.draw(6, c, 0, 0), h.end(), e.queue.submit([u.finish()]);
+		}
+		return {
+			frame: O,
+			shouldContinue: i,
+			resize: D,
+			teardown: () => {
+				f.destroy(), p.destroy(), m.destroy();
+			}
+		};
+	};
+}
+//#endregion
+//#region src/components/custom/dot-flow-field/shaders/flow-field.glsl.ts
+function Q(e, t) {
+	let n = Math.sin(e * 71.13 + t * 13.7) * 43758.5453;
+	return n -= Math.floor(n), n;
+}
+function se(e) {
+	let t = Math.min(Math.max(e.particleCount, 1), M), n = .85, r = [];
+	function i(e, t) {
+		let r = Q(e, t), i = Q(e + 4, t + 2);
+		return {
+			x: (r * 2 - 1) * n,
+			y: (i * 2 - 1) * n
+		};
+	}
+	for (let e = 0; e < t; e++) {
+		let t = (e + 1) * .6180339887, n = i(t, e * .137);
+		r.push({
+			pos: n,
+			age: Q(t, 7) * 6,
+			seed: t
+		});
+	}
+	let a = e.waveComponents;
+	function o(t, o) {
+		let s = e.windSpeed, c = e.curlStrength;
+		for (let e of r) {
+			let r = A(e.pos, o, a, s, c);
+			e.pos.x += r.x * t, e.pos.y += r.y * t, e.age += t, (Math.abs(e.pos.x) > n || Math.abs(e.pos.y) > n || e.age > 6) && (e.pos = i(e.seed, e.age), e.age = 0);
+		}
+	}
+	function s(t, i, o, s, c) {
+		t.clearRect(0, 0, i, o);
+		let l = i / 2, u = o / 2, d = Math.min(i, o) / (2 * n);
+		t.fillStyle = c;
+		let f = e.windSpeed, p = e.curlStrength;
+		for (let n of r) {
+			let r = A(n.pos, s, a, f, p), i = Math.hypot(r.x, r.y), o = Math.min(i / 2, 1), c = e.dotSize * (1 - o * e.dotSizeVelocity), m = 1 - o * .35, h = l + n.pos.x * d, g = u + n.pos.y * d;
+			t.globalAlpha = Math.max(m, .1), t.beginPath(), t.arc(h, g, Math.max(c, .4), 0, Math.PI * 2), t.fill();
+		}
+		t.globalAlpha = 1;
+	}
+	return {
+		particles: r,
+		step: o,
+		paint: s
+	};
+}
+//#endregion
+//#region src/components/custom/dot-flow-field/composables/useDotFlowField.ts
+function $(t, r) {
+	let { config: a, getPalette: o } = r, s = r.mode ?? "live";
+	if (i()) {
+		let e = null, r = () => {
+			let r = t.value;
+			return r ? (e || (e = n(r, {
+				mode: s,
+				respectReducedMotion: a.respectReducedMotion,
+				setupWGPU: oe({
+					canvas: r,
+					config: a,
+					getPalette: o,
+					shouldContinue: () => !0,
+					getReducedMotion: () => e?.reducedMotion ?? !1
+				}),
+				setupGL: () => ({
+					frame: () => {},
+					shouldContinue: () => !1,
+					resize: () => {}
+				})
+			}), e.armAsync()), e) : null;
+		};
+		queueMicrotask(() => r());
+		let i = {
+			get backend() {
+				return r()?.backend ?? "webgpu";
+			},
+			pause: () => r()?.suspend("manual"),
+			resume: () => r()?.resume("manual"),
+			wake: () => r()?.wake(),
+			renderAt: (e) => r()?.renderAt(e),
+			get reducedMotion() {
+				return e?.reducedMotion ?? !1;
+			},
+			dispose: () => e?.dispose()
+		};
+		return m(() => i.dispose()), i;
+	}
+	let l = se(a), u = -1, d = e({
+		canvas: () => t.value,
+		respectReducedMotion: a.respectReducedMotion,
+		autoStart: s === "live",
+		setup: (e) => ({ render: (e, n) => {
+			let r = n / 1e3, i = u < 0 ? 0 : Math.min(Math.max((n - u) / 1e3, 0), .05);
+			u = n, i > 0 && l.step(i, r);
+			let s = t.value, d = s?.clientWidth || 320, f = s?.clientHeight || 320, p = o()[0] ?? a.palette[0];
+			l.paint(e, d, f, r, c(p));
+		} })
+	}), f = {
+		backend: "webgl2",
+		pause: () => d.suspend("manual"),
+		resume: () => d.resume("manual"),
+		wake: () => d.wake(),
+		renderAt: () => {
+			d.wake();
+		},
+		get reducedMotion() {
+			return d.reducedMotion;
+		},
+		dispose: () => d.dispose()
+	};
+	return m(() => f.dispose()), f;
+}
+//#endregion
+//#region src/components/custom/dot-flow-field/DotFlowField.vue
+var ce = /* @__PURE__ */ t(/* @__PURE__ */ f({
+	__name: "DotFlowField",
+	props: {
+		config: { default: () => R },
+		paused: {
+			type: Boolean,
+			default: !1
+		}
+	},
+	emits: ["update:paused"],
+	setup(e, { expose: t }) {
+		let n = g("canvasRef"), r = $(n, {
+			config: e.config,
+			getPalette: () => e.config.palette
+		});
+		_(() => e.paused, (e) => e ? r.pause() : r.resume(), { immediate: !0 });
+		let i = l(() => {
+			let t = e.config.background;
+			if (t !== "transparent") return `oklch(${t.L} ${t.C} ${t.h})`;
+		});
+		return t({
+			pause: r.pause,
+			resume: r.resume,
+			wake: r.wake,
+			renderAt: r.renderAt
+		}), (e, t) => (h(), u("div", {
+			class: "dot-flow-field-wrapper",
+			style: p(i.value ? { background: i.value } : void 0)
+		}, [d("canvas", {
+			ref_key: "canvasRef",
+			ref: n,
+			class: "dot-flow-field-canvas",
+			"aria-hidden": "true",
+			"data-testid": "dot-flow-field-canvas"
+		}, null, 512)], 4));
+	}
+}), [["__scopeId", "data-v-70541ba6"]]);
+//#endregion
+export { R as DEFAULT_FLOW_CONFIG, F as DEFAULT_PARTICLE_COUNT, L as DEFAULT_WAVE_COMPONENTS, ce as DotFlowField, b as FLOW_GRAVITY, P as MAX_FLOW_STOPS, M as MAX_PARTICLES, N as MAX_WAVE_COMPONENTS, I as WARM_IDENTITY_PALETTE, j as buildWaveLadder, k as curlFBM, C as gerstnerVelocity, A as sampleVelocity, $ as useDotFlowField };

package/dist/drawer.d.ts

@@ -0,0 +1 @@
+export * from "./components/ui/drawer";