sprae 10.9.2 → 10.9.4
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/directive/style.js +4 -5
- package/dist/sprae.js +10 -6
- package/dist/sprae.js.map +2 -2
- package/dist/sprae.min.js +3 -3
- package/dist/sprae.min.js.map +4 -4
- package/dist/sprae.umd.js +625 -56
- package/dist/sprae.umd.js.map +4 -4
- package/dist/sprae.umd.min.js +3 -33
- package/dist/sprae.umd.min.js.map +4 -4
- package/package.json +1 -2
- package/readme.md +13 -26
- package/sprae.js +6 -0
package/dist/sprae.umd.js
CHANGED
|
@@ -1,63 +1,632 @@
|
|
|
1
|
-
(
|
|
2
|
-
|
|
3
|
-
|
|
4
|
-
|
|
5
|
-
|
|
6
|
-
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
|
|
10
|
-
|
|
11
|
-
|
|
12
|
-
var
|
|
13
|
-
var
|
|
14
|
-
|
|
15
|
-
|
|
16
|
-
|
|
17
|
-
|
|
18
|
-
|
|
19
|
-
|
|
20
|
-
|
|
21
|
-
|
|
22
|
-
|
|
23
|
-
|
|
24
|
-
var
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
|
|
28
|
-
|
|
29
|
-
|
|
30
|
-
|
|
31
|
-
|
|
32
|
-
|
|
33
|
-
|
|
34
|
-
|
|
35
|
-
|
|
36
|
-
|
|
37
|
-
|
|
38
|
-
|
|
1
|
+
(() => {
|
|
2
|
+
var __defProp = Object.defineProperty;
|
|
3
|
+
var __export = (target, all) => {
|
|
4
|
+
for (var name in all)
|
|
5
|
+
__defProp(target, name, { get: all[name], enumerable: true });
|
|
6
|
+
};
|
|
7
|
+
|
|
8
|
+
// signal.js
|
|
9
|
+
var signal;
|
|
10
|
+
var effect;
|
|
11
|
+
var untracked;
|
|
12
|
+
var batch;
|
|
13
|
+
var computed;
|
|
14
|
+
function use(s) {
|
|
15
|
+
signal = s.signal;
|
|
16
|
+
effect = s.effect;
|
|
17
|
+
computed = s.computed;
|
|
18
|
+
batch = s.batch || ((fn) => fn());
|
|
19
|
+
untracked = s.untracked || batch;
|
|
20
|
+
}
|
|
21
|
+
|
|
22
|
+
// store.js
|
|
23
|
+
var _signals = Symbol("signals");
|
|
24
|
+
var _change = Symbol("length");
|
|
25
|
+
function store(values, parent) {
|
|
26
|
+
if (!values)
|
|
27
|
+
return values;
|
|
28
|
+
if (values[_signals])
|
|
29
|
+
return values;
|
|
30
|
+
if (Array.isArray(values))
|
|
31
|
+
return list(values);
|
|
32
|
+
if (values.constructor !== Object)
|
|
33
|
+
return values;
|
|
34
|
+
let signals = { ...parent?.[_signals] }, _len = signal(Object.values(values).length);
|
|
35
|
+
const state = new Proxy(signals, {
|
|
36
|
+
get: (_, key) => key === _change ? _len : key === _signals ? signals : signals[key]?.valueOf(),
|
|
37
|
+
set: (_, key, v, s) => (s = signals[key], set(signals, key, v), s ?? ++_len.value, 1),
|
|
38
|
+
deleteProperty: (_, key) => (signals[key] && (del(signals, key), _len.value--), 1),
|
|
39
|
+
ownKeys() {
|
|
40
|
+
_len.value;
|
|
41
|
+
return Reflect.ownKeys(signals);
|
|
42
|
+
}
|
|
43
|
+
});
|
|
44
|
+
for (let key in values) {
|
|
45
|
+
const desc = Object.getOwnPropertyDescriptor(values, key);
|
|
46
|
+
if (desc?.get) {
|
|
47
|
+
(signals[key] = computed(desc.get.bind(state)))._set = desc.set?.bind(state);
|
|
48
|
+
} else {
|
|
49
|
+
signals[key] = void 0;
|
|
50
|
+
set(signals, key, values[key]);
|
|
51
|
+
}
|
|
52
|
+
}
|
|
53
|
+
return state;
|
|
54
|
+
}
|
|
55
|
+
var mut = { push: 1, pop: 1, shift: 1, unshift: 1, splice: 1 };
|
|
56
|
+
function list(values) {
|
|
57
|
+
let lastProp;
|
|
58
|
+
if (values[_signals])
|
|
59
|
+
return values;
|
|
60
|
+
let _len = signal(values.length), signals = Array(values.length).fill();
|
|
61
|
+
const state = new Proxy(signals, {
|
|
62
|
+
get(_, key) {
|
|
63
|
+
if (typeof key === "symbol")
|
|
64
|
+
return key === _change ? _len : key === _signals ? signals : signals[key];
|
|
65
|
+
if (key === "length")
|
|
66
|
+
return mut[lastProp] ? _len.peek() : _len.value;
|
|
67
|
+
lastProp = key;
|
|
68
|
+
if (signals[key])
|
|
69
|
+
return signals[key].valueOf();
|
|
70
|
+
if (key < signals.length)
|
|
71
|
+
return (signals[key] = signal(store(values[key]))).value;
|
|
72
|
+
},
|
|
73
|
+
set(_, key, v) {
|
|
74
|
+
if (key === "length") {
|
|
75
|
+
for (let i = v, l = signals.length; i < l; i++)
|
|
76
|
+
delete state[i];
|
|
77
|
+
_len.value = signals.length = v;
|
|
78
|
+
return true;
|
|
79
|
+
}
|
|
80
|
+
set(signals, key, v);
|
|
81
|
+
if (key >= _len.peek())
|
|
82
|
+
_len.value = signals.length = Number(key) + 1;
|
|
83
|
+
return true;
|
|
84
|
+
},
|
|
85
|
+
deleteProperty: (_, key) => (signals[key] && del(signals, key), 1)
|
|
86
|
+
});
|
|
87
|
+
return state;
|
|
88
|
+
}
|
|
89
|
+
function set(signals, key, v) {
|
|
90
|
+
let s = signals[key];
|
|
91
|
+
if (key[0] === "_")
|
|
92
|
+
signals[key] = v;
|
|
93
|
+
else if (!s) {
|
|
94
|
+
signals[key] = s = v?.peek ? v : signal(store(v));
|
|
95
|
+
} else if (v === s.peek())
|
|
96
|
+
;
|
|
97
|
+
else if (s._set)
|
|
98
|
+
s._set(v);
|
|
99
|
+
else if (Array.isArray(v) && Array.isArray(s.peek())) {
|
|
100
|
+
const cur = s.peek();
|
|
101
|
+
if (cur[_change])
|
|
102
|
+
untracked(() => {
|
|
103
|
+
batch(() => {
|
|
104
|
+
let i = 0, l = v.length;
|
|
105
|
+
for (; i < l; i++)
|
|
106
|
+
cur[i] = v[i];
|
|
107
|
+
cur.length = l;
|
|
108
|
+
});
|
|
39
109
|
});
|
|
110
|
+
else {
|
|
111
|
+
s.value = v;
|
|
40
112
|
}
|
|
113
|
+
} else {
|
|
114
|
+
s.value = store(v);
|
|
115
|
+
}
|
|
116
|
+
}
|
|
117
|
+
function del(signals, key) {
|
|
118
|
+
const s = signals[key], del2 = s[Symbol.dispose];
|
|
119
|
+
if (del2)
|
|
120
|
+
delete s[Symbol.dispose];
|
|
121
|
+
delete signals[key];
|
|
122
|
+
del2?.();
|
|
123
|
+
}
|
|
124
|
+
|
|
125
|
+
// core.js
|
|
126
|
+
var _dispose = Symbol.dispose || (Symbol.dispose = Symbol("dispose"));
|
|
127
|
+
var directive = {};
|
|
128
|
+
var memo = /* @__PURE__ */ new WeakMap();
|
|
129
|
+
function sprae(el, values) {
|
|
130
|
+
if (!el?.childNodes)
|
|
131
|
+
return;
|
|
132
|
+
if (memo.has(el)) {
|
|
133
|
+
return Object.assign(memo.get(el), values);
|
|
134
|
+
}
|
|
135
|
+
const state = store(values || {}), disposes = [];
|
|
136
|
+
init(el);
|
|
137
|
+
if (!memo.has(el))
|
|
138
|
+
memo.set(el, state);
|
|
139
|
+
el[_dispose] = () => {
|
|
140
|
+
while (disposes.length)
|
|
141
|
+
disposes.pop()();
|
|
142
|
+
memo.delete(el);
|
|
143
|
+
};
|
|
144
|
+
return state;
|
|
145
|
+
function init(el2, parent = el2.parentNode) {
|
|
146
|
+
if (!el2.childNodes)
|
|
147
|
+
return;
|
|
148
|
+
for (let i = 0; i < el2.attributes?.length; ) {
|
|
149
|
+
let attr2 = el2.attributes[i];
|
|
150
|
+
if (attr2.name[0] === ":") {
|
|
151
|
+
el2.removeAttribute(attr2.name);
|
|
152
|
+
let names = attr2.name.slice(1).split(":");
|
|
153
|
+
for (let name of names) {
|
|
154
|
+
let dir = directive[name] || directive.default;
|
|
155
|
+
let evaluate = (dir.parse || parse)(attr2.value);
|
|
156
|
+
let dispose = dir(el2, evaluate, state, name);
|
|
157
|
+
if (dispose)
|
|
158
|
+
disposes.push(dispose);
|
|
159
|
+
}
|
|
160
|
+
if (memo.has(el2))
|
|
161
|
+
return el2[_dispose] && disposes.push(el2[_dispose]);
|
|
162
|
+
if (el2.parentNode !== parent)
|
|
163
|
+
return;
|
|
164
|
+
} else
|
|
165
|
+
i++;
|
|
166
|
+
}
|
|
167
|
+
for (let child of [...el2.childNodes])
|
|
168
|
+
init(child, el2);
|
|
169
|
+
}
|
|
170
|
+
;
|
|
171
|
+
}
|
|
172
|
+
var evalMemo = {};
|
|
173
|
+
var parse = (expr, dir, fn) => {
|
|
174
|
+
if (fn = evalMemo[expr = expr.trim()])
|
|
175
|
+
return fn;
|
|
176
|
+
try {
|
|
177
|
+
fn = compile(expr);
|
|
178
|
+
} catch (e) {
|
|
179
|
+
err(e, dir, expr);
|
|
41
180
|
}
|
|
42
|
-
return
|
|
181
|
+
return evalMemo[expr] = fn;
|
|
43
182
|
};
|
|
44
|
-
|
|
45
|
-
}
|
|
46
|
-
|
|
47
|
-
}
|
|
48
|
-
|
|
49
|
-
|
|
50
|
-
|
|
51
|
-
|
|
52
|
-
|
|
53
|
-
|
|
54
|
-
|
|
55
|
-
|
|
183
|
+
var err = (e, dir, expr = "") => {
|
|
184
|
+
throw Object.assign(e, { message: `\u2234 ${e.message}
|
|
185
|
+
|
|
186
|
+
${dir}${expr ? `="${expr}"
|
|
187
|
+
|
|
188
|
+
` : ""}`, expr });
|
|
189
|
+
};
|
|
190
|
+
var compile;
|
|
191
|
+
sprae.use = (s) => {
|
|
192
|
+
s.signal && use(s);
|
|
193
|
+
s.compile && (compile = s.compile);
|
|
194
|
+
};
|
|
195
|
+
var frag = (tpl) => {
|
|
196
|
+
if (!tpl.nodeType)
|
|
197
|
+
return tpl;
|
|
198
|
+
let content = tpl.content.cloneNode(true), attributes = [...tpl.attributes], ref = document.createTextNode(""), childNodes = (content.append(ref), [...content.childNodes]);
|
|
199
|
+
return {
|
|
200
|
+
childNodes,
|
|
201
|
+
content,
|
|
202
|
+
remove: () => content.append(...childNodes),
|
|
203
|
+
replaceWith(el) {
|
|
204
|
+
if (el === ref)
|
|
205
|
+
return;
|
|
206
|
+
ref.before(el);
|
|
207
|
+
content.append(...childNodes);
|
|
208
|
+
},
|
|
209
|
+
attributes,
|
|
210
|
+
removeAttribute(name) {
|
|
211
|
+
attributes.splice(attributes.findIndex((a) => a.name === name), 1);
|
|
212
|
+
}
|
|
213
|
+
};
|
|
214
|
+
};
|
|
215
|
+
|
|
216
|
+
// node_modules/ulive/dist/ulive.es.js
|
|
217
|
+
var ulive_es_exports = {};
|
|
218
|
+
__export(ulive_es_exports, {
|
|
219
|
+
batch: () => batch2,
|
|
220
|
+
computed: () => computed2,
|
|
221
|
+
effect: () => effect2,
|
|
222
|
+
signal: () => signal2,
|
|
223
|
+
untracked: () => untracked2
|
|
224
|
+
});
|
|
225
|
+
var current;
|
|
226
|
+
var batched;
|
|
227
|
+
var signal2 = (v, s, obs = /* @__PURE__ */ new Set()) => (s = {
|
|
228
|
+
get value() {
|
|
229
|
+
current?.deps.push(obs.add(current));
|
|
230
|
+
return v;
|
|
231
|
+
},
|
|
232
|
+
set value(val) {
|
|
233
|
+
if (val === v)
|
|
234
|
+
return;
|
|
235
|
+
v = val;
|
|
236
|
+
for (let sub of obs)
|
|
237
|
+
batched ? batched.add(sub) : sub();
|
|
238
|
+
},
|
|
239
|
+
peek() {
|
|
240
|
+
return v;
|
|
241
|
+
}
|
|
242
|
+
}, s.toJSON = s.then = s.toString = s.valueOf = () => s.value, s);
|
|
243
|
+
var effect2 = (fn, teardown, fx, deps) => (fx = (prev) => {
|
|
244
|
+
teardown?.call?.();
|
|
245
|
+
prev = current, current = fx;
|
|
246
|
+
try {
|
|
247
|
+
teardown = fn();
|
|
248
|
+
} finally {
|
|
249
|
+
current = prev;
|
|
250
|
+
}
|
|
251
|
+
}, deps = fx.deps = [], fx(), (dep) => {
|
|
252
|
+
teardown?.call?.();
|
|
253
|
+
while (dep = deps.pop())
|
|
254
|
+
dep.delete(fx);
|
|
255
|
+
});
|
|
256
|
+
var computed2 = (fn, s = signal2(), c, e) => (c = {
|
|
257
|
+
get value() {
|
|
258
|
+
e || (e = effect2(() => s.value = fn()));
|
|
259
|
+
return s.value;
|
|
260
|
+
},
|
|
261
|
+
peek: s.peek
|
|
262
|
+
}, c.toJSON = c.then = c.toString = c.valueOf = () => c.value, c);
|
|
263
|
+
var batch2 = (fn) => {
|
|
264
|
+
let fxs = batched;
|
|
265
|
+
if (!fxs)
|
|
266
|
+
batched = /* @__PURE__ */ new Set();
|
|
267
|
+
try {
|
|
268
|
+
fn();
|
|
269
|
+
} finally {
|
|
270
|
+
if (!fxs) {
|
|
271
|
+
fxs = batched;
|
|
272
|
+
batched = null;
|
|
273
|
+
for (const fx of fxs)
|
|
274
|
+
fx();
|
|
56
275
|
}
|
|
57
276
|
}
|
|
58
|
-
return to;
|
|
59
277
|
};
|
|
60
|
-
|
|
61
|
-
|
|
62
|
-
|
|
63
|
-
|
|
278
|
+
var untracked2 = (fn, prev, v) => (prev = current, current = null, v = fn(), current = prev, v);
|
|
279
|
+
|
|
280
|
+
// directive/if.js
|
|
281
|
+
var _prevIf = Symbol("if");
|
|
282
|
+
directive.if = (el, evaluate, state) => {
|
|
283
|
+
let next = el.nextElementSibling, holder = document.createTextNode(""), curEl, ifEl, elseEl;
|
|
284
|
+
el.replaceWith(holder);
|
|
285
|
+
ifEl = el.content ? frag(el) : el;
|
|
286
|
+
memo.set(ifEl, null);
|
|
287
|
+
if (next?.hasAttribute(":else")) {
|
|
288
|
+
next.removeAttribute(":else");
|
|
289
|
+
if (!next.hasAttribute(":if"))
|
|
290
|
+
next.remove(), elseEl = next.content ? frag(next) : next, memo.set(elseEl, null);
|
|
291
|
+
}
|
|
292
|
+
return effect(() => {
|
|
293
|
+
const newEl = evaluate(state) ? ifEl : el[_prevIf] ? null : elseEl;
|
|
294
|
+
if (next)
|
|
295
|
+
next[_prevIf] = newEl === ifEl;
|
|
296
|
+
if (curEl != newEl) {
|
|
297
|
+
curEl?.remove();
|
|
298
|
+
if (curEl = newEl) {
|
|
299
|
+
holder.before(curEl.content || curEl);
|
|
300
|
+
memo.get(curEl) === null && memo.delete(curEl);
|
|
301
|
+
sprae(curEl, state);
|
|
302
|
+
}
|
|
303
|
+
}
|
|
304
|
+
});
|
|
305
|
+
};
|
|
306
|
+
|
|
307
|
+
// directive/each.js
|
|
308
|
+
directive.each = (tpl, [itemVar, idxVar, evaluate], state) => {
|
|
309
|
+
const holder = document.createTextNode("");
|
|
310
|
+
tpl.replaceWith(holder);
|
|
311
|
+
let cur, keys2, prevl = 0;
|
|
312
|
+
const items = computed(() => {
|
|
313
|
+
keys2 = null;
|
|
314
|
+
let items2 = evaluate(state);
|
|
315
|
+
if (typeof items2 === "number")
|
|
316
|
+
items2 = Array.from({ length: items2 }, (_, i) => i + 1);
|
|
317
|
+
if (items2?.constructor === Object)
|
|
318
|
+
keys2 = Object.keys(items2), items2 = Object.values(items2);
|
|
319
|
+
return items2 || [];
|
|
320
|
+
});
|
|
321
|
+
const update = () => {
|
|
322
|
+
untracked(() => {
|
|
323
|
+
var _a, _b;
|
|
324
|
+
let i = 0, newItems = items.value, newl = newItems.length;
|
|
325
|
+
if (cur && !cur[_change]) {
|
|
326
|
+
for (let s of cur[_signals] || []) {
|
|
327
|
+
s[Symbol.dispose]();
|
|
328
|
+
}
|
|
329
|
+
cur = null, prevl = 0;
|
|
330
|
+
}
|
|
331
|
+
if (newl < prevl) {
|
|
332
|
+
cur.length = newl;
|
|
333
|
+
} else {
|
|
334
|
+
if (!cur) {
|
|
335
|
+
cur = newItems;
|
|
336
|
+
} else {
|
|
337
|
+
for (; i < prevl; i++) {
|
|
338
|
+
cur[i] = newItems[i];
|
|
339
|
+
}
|
|
340
|
+
}
|
|
341
|
+
for (; i < newl; i++) {
|
|
342
|
+
cur[i] = newItems[i];
|
|
343
|
+
let idx = i, scope = store({
|
|
344
|
+
[itemVar]: cur[_signals]?.[idx] || cur[idx],
|
|
345
|
+
[idxVar]: keys2 ? keys2[idx] : idx
|
|
346
|
+
}, state), el = tpl.content ? frag(tpl) : tpl.cloneNode(true);
|
|
347
|
+
holder.before(el.content || el);
|
|
348
|
+
sprae(el, scope);
|
|
349
|
+
((_b = cur[_a = _signals] || (cur[_a] = []))[i] || (_b[i] = {}))[Symbol.dispose] = () => {
|
|
350
|
+
el[Symbol.dispose](), el.remove();
|
|
351
|
+
};
|
|
352
|
+
}
|
|
353
|
+
}
|
|
354
|
+
prevl = newl;
|
|
355
|
+
});
|
|
356
|
+
};
|
|
357
|
+
let planned = 0;
|
|
358
|
+
return effect(() => {
|
|
359
|
+
items.value[_change]?.value;
|
|
360
|
+
if (!planned) {
|
|
361
|
+
update();
|
|
362
|
+
queueMicrotask(() => (planned && update(), planned = 0));
|
|
363
|
+
} else
|
|
364
|
+
planned++;
|
|
365
|
+
});
|
|
366
|
+
};
|
|
367
|
+
directive.each.parse = (expr) => {
|
|
368
|
+
let [leftSide, itemsExpr] = expr.split(/\s+in\s+/);
|
|
369
|
+
let [itemVar, idxVar = "$"] = leftSide.split(/\s*,\s*/);
|
|
370
|
+
return [itemVar, idxVar, parse(itemsExpr)];
|
|
371
|
+
};
|
|
372
|
+
|
|
373
|
+
// directive/ref.js
|
|
374
|
+
directive.ref = (el, expr, state) => {
|
|
375
|
+
state[expr] = el;
|
|
376
|
+
};
|
|
377
|
+
directive.ref.parse = (expr) => expr;
|
|
378
|
+
|
|
379
|
+
// directive/with.js
|
|
380
|
+
directive.with = (el, evaluate, rootState) => {
|
|
381
|
+
let state;
|
|
382
|
+
return effect(() => {
|
|
383
|
+
let values = evaluate(rootState);
|
|
384
|
+
sprae(el, state ? values : state = store(values, rootState));
|
|
385
|
+
});
|
|
386
|
+
};
|
|
387
|
+
|
|
388
|
+
// directive/html.js
|
|
389
|
+
directive.html = (el, evaluate, state) => {
|
|
390
|
+
let tpl = evaluate(state);
|
|
391
|
+
if (!tpl)
|
|
392
|
+
return;
|
|
393
|
+
let content = (tpl.content || tpl).cloneNode(true);
|
|
394
|
+
el.replaceChildren(content);
|
|
395
|
+
sprae(el, state);
|
|
396
|
+
};
|
|
397
|
+
|
|
398
|
+
// directive/text.js
|
|
399
|
+
directive.text = (el, evaluate, state) => {
|
|
400
|
+
if (el.content)
|
|
401
|
+
el.replaceWith(el = frag(el).childNodes[0]);
|
|
402
|
+
return effect(() => {
|
|
403
|
+
let value = evaluate(state);
|
|
404
|
+
el.textContent = value == null ? "" : value;
|
|
405
|
+
});
|
|
406
|
+
};
|
|
407
|
+
|
|
408
|
+
// directive/class.js
|
|
409
|
+
directive.class = (el, evaluate, state) => {
|
|
410
|
+
let cur = /* @__PURE__ */ new Set();
|
|
411
|
+
return effect(() => {
|
|
412
|
+
let v = evaluate(state);
|
|
413
|
+
let clsx = /* @__PURE__ */ new Set();
|
|
414
|
+
if (v) {
|
|
415
|
+
if (typeof v === "string")
|
|
416
|
+
v.split(" ").map((cls) => clsx.add(cls));
|
|
417
|
+
else if (Array.isArray(v))
|
|
418
|
+
v.map((v2) => v2 && clsx.add(v2));
|
|
419
|
+
else
|
|
420
|
+
Object.entries(v).map(([k, v2]) => v2 && clsx.add(k));
|
|
421
|
+
}
|
|
422
|
+
for (let cls of cur)
|
|
423
|
+
if (clsx.has(cls))
|
|
424
|
+
clsx.delete(cls);
|
|
425
|
+
else
|
|
426
|
+
el.classList.remove(cls);
|
|
427
|
+
for (let cls of cur = clsx)
|
|
428
|
+
el.classList.add(cls);
|
|
429
|
+
});
|
|
430
|
+
};
|
|
431
|
+
|
|
432
|
+
// directive/style.js
|
|
433
|
+
directive.style = (el, evaluate, state) => {
|
|
434
|
+
let initStyle = el.getAttribute("style");
|
|
435
|
+
return effect(() => {
|
|
436
|
+
let v = evaluate(state);
|
|
437
|
+
if (typeof v === "string")
|
|
438
|
+
el.setAttribute("style", initStyle + (initStyle.endsWith(";") ? "" : "; ") + v);
|
|
439
|
+
else {
|
|
440
|
+
if (initStyle)
|
|
441
|
+
el.setAttribute("style", initStyle);
|
|
442
|
+
for (let k in v)
|
|
443
|
+
k[0] == "-" ? el.style.setProperty(k, v[k]) : el.style[k] = v[k];
|
|
444
|
+
}
|
|
445
|
+
});
|
|
446
|
+
};
|
|
447
|
+
|
|
448
|
+
// directive/default.js
|
|
449
|
+
directive.default = (target, evaluate, state, name) => {
|
|
450
|
+
if (!name.startsWith("on"))
|
|
451
|
+
return effect(() => {
|
|
452
|
+
let value = evaluate(state);
|
|
453
|
+
if (name)
|
|
454
|
+
attr(target, name, value);
|
|
455
|
+
else
|
|
456
|
+
for (let key in value)
|
|
457
|
+
attr(target, dashcase(key), value[key]);
|
|
458
|
+
});
|
|
459
|
+
const ctxs = name.split("..").map((e) => {
|
|
460
|
+
let ctx = { evt: "", target, test: () => true };
|
|
461
|
+
ctx.evt = (e.startsWith("on") ? e.slice(2) : e).replace(
|
|
462
|
+
/\.(\w+)?-?([-\w]+)?/g,
|
|
463
|
+
(match, mod, param = "") => (ctx.test = mods[mod]?.(ctx, ...param.split("-")) || ctx.test, "")
|
|
464
|
+
);
|
|
465
|
+
return ctx;
|
|
466
|
+
});
|
|
467
|
+
if (ctxs.length == 1)
|
|
468
|
+
return effect(() => addListener(evaluate(state), ctxs[0]));
|
|
469
|
+
let startFn, nextFn, off, idx = 0;
|
|
470
|
+
const nextListener = (fn) => {
|
|
471
|
+
off = addListener((e) => (off(), nextFn = fn?.(e), (idx = ++idx % ctxs.length) ? nextListener(nextFn) : startFn && nextListener(startFn)), ctxs[idx]);
|
|
472
|
+
};
|
|
473
|
+
return effect(() => (startFn = evaluate(state), !off && nextListener(startFn), () => startFn = null));
|
|
474
|
+
function addListener(fn, { evt, target: target2, test, defer, stop, prevent, immediate, ...opts }) {
|
|
475
|
+
if (defer)
|
|
476
|
+
fn = defer(fn);
|
|
477
|
+
const cb = (e) => {
|
|
478
|
+
try {
|
|
479
|
+
test(e) && (stop && (immediate ? e.stopImmediatePropagation() : e.stopPropagation()), prevent && e.preventDefault(), fn?.(e));
|
|
480
|
+
} catch (error) {
|
|
481
|
+
err(error, `:on${evt}`, fn);
|
|
482
|
+
}
|
|
483
|
+
};
|
|
484
|
+
target2.addEventListener(evt, cb, opts);
|
|
485
|
+
return () => target2.removeEventListener(evt, cb, opts);
|
|
486
|
+
}
|
|
487
|
+
;
|
|
488
|
+
};
|
|
489
|
+
var mods = {
|
|
490
|
+
prevent(ctx) {
|
|
491
|
+
ctx.prevent = true;
|
|
492
|
+
},
|
|
493
|
+
stop(ctx) {
|
|
494
|
+
ctx.stop = true;
|
|
495
|
+
},
|
|
496
|
+
immediate(ctx) {
|
|
497
|
+
ctx.immediate = true;
|
|
498
|
+
},
|
|
499
|
+
once(ctx) {
|
|
500
|
+
ctx.once = true;
|
|
501
|
+
},
|
|
502
|
+
passive(ctx) {
|
|
503
|
+
ctx.passive = true;
|
|
504
|
+
},
|
|
505
|
+
capture(ctx) {
|
|
506
|
+
ctx.capture = true;
|
|
507
|
+
},
|
|
508
|
+
window(ctx) {
|
|
509
|
+
ctx.target = window;
|
|
510
|
+
},
|
|
511
|
+
document(ctx) {
|
|
512
|
+
ctx.target = document;
|
|
513
|
+
},
|
|
514
|
+
throttle(ctx, limit) {
|
|
515
|
+
ctx.defer = (fn) => throttle(fn, limit ? Number(limit) || 0 : 108);
|
|
516
|
+
},
|
|
517
|
+
debounce(ctx, wait) {
|
|
518
|
+
ctx.defer = (fn) => debounce(fn, wait ? Number(wait) || 0 : 108);
|
|
519
|
+
},
|
|
520
|
+
outside: (ctx) => (e) => {
|
|
521
|
+
let target = ctx.target;
|
|
522
|
+
if (target.contains(e.target))
|
|
523
|
+
return false;
|
|
524
|
+
if (e.target.isConnected === false)
|
|
525
|
+
return false;
|
|
526
|
+
if (target.offsetWidth < 1 && target.offsetHeight < 1)
|
|
527
|
+
return false;
|
|
528
|
+
return true;
|
|
529
|
+
},
|
|
530
|
+
self: (ctx) => (e) => e.target === ctx.target,
|
|
531
|
+
ctrl: (_, ...param) => (e) => keys.ctrl(e) && param.every((p) => keys[p] ? keys[p](e) : e.key === p),
|
|
532
|
+
shift: (_, ...param) => (e) => keys.shift(e) && param.every((p) => keys[p] ? keys[p](e) : e.key === p),
|
|
533
|
+
alt: (_, ...param) => (e) => keys.alt(e) && param.every((p) => keys[p] ? keys[p](e) : e.key === p),
|
|
534
|
+
meta: (_, ...param) => (e) => keys.meta(e) && param.every((p) => keys[p] ? keys[p](e) : e.key === p),
|
|
535
|
+
arrow: () => keys.arrow,
|
|
536
|
+
enter: () => keys.enter,
|
|
537
|
+
esc: () => keys.esc,
|
|
538
|
+
tab: () => keys.tab,
|
|
539
|
+
space: () => keys.space,
|
|
540
|
+
delete: () => keys.delete,
|
|
541
|
+
digit: () => keys.digit,
|
|
542
|
+
letter: () => keys.letter,
|
|
543
|
+
char: () => keys.char
|
|
544
|
+
};
|
|
545
|
+
var keys = {
|
|
546
|
+
ctrl: (e) => e.ctrlKey || e.key === "Control" || e.key === "Ctrl",
|
|
547
|
+
shift: (e) => e.shiftKey || e.key === "Shift",
|
|
548
|
+
alt: (e) => e.altKey || e.key === "Alt",
|
|
549
|
+
meta: (e) => e.metaKey || e.key === "Meta" || e.key === "Command",
|
|
550
|
+
arrow: (e) => e.key.startsWith("Arrow"),
|
|
551
|
+
enter: (e) => e.key === "Enter",
|
|
552
|
+
esc: (e) => e.key.startsWith("Esc"),
|
|
553
|
+
tab: (e) => e.key === "Tab",
|
|
554
|
+
space: (e) => e.key === "\xA0" || e.key === "Space" || e.key === " ",
|
|
555
|
+
delete: (e) => e.key === "Delete" || e.key === "Backspace",
|
|
556
|
+
digit: (e) => /^\d$/.test(e.key),
|
|
557
|
+
letter: (e) => /^\p{L}$/gu.test(e.key),
|
|
558
|
+
char: (e) => /^\S$/.test(e.key)
|
|
559
|
+
};
|
|
560
|
+
var attr = (el, name, v) => {
|
|
561
|
+
if (v == null || v === false)
|
|
562
|
+
el.removeAttribute(name);
|
|
563
|
+
else
|
|
564
|
+
el.setAttribute(name, v === true ? "" : typeof v === "number" || typeof v === "string" ? v : "");
|
|
565
|
+
};
|
|
566
|
+
var throttle = (fn, limit) => {
|
|
567
|
+
let pause, planned, block = (e) => {
|
|
568
|
+
pause = true;
|
|
569
|
+
setTimeout(() => {
|
|
570
|
+
pause = false;
|
|
571
|
+
if (planned)
|
|
572
|
+
return planned = false, block(e), fn(e);
|
|
573
|
+
}, limit);
|
|
574
|
+
};
|
|
575
|
+
return (e) => {
|
|
576
|
+
if (pause)
|
|
577
|
+
return planned = true;
|
|
578
|
+
block(e);
|
|
579
|
+
return fn(e);
|
|
580
|
+
};
|
|
581
|
+
};
|
|
582
|
+
var debounce = (fn, wait) => {
|
|
583
|
+
let timeout;
|
|
584
|
+
return (e) => {
|
|
585
|
+
clearTimeout(timeout);
|
|
586
|
+
timeout = setTimeout(() => {
|
|
587
|
+
timeout = null;
|
|
588
|
+
fn(e);
|
|
589
|
+
}, wait);
|
|
590
|
+
};
|
|
591
|
+
};
|
|
592
|
+
var dashcase = (str) => {
|
|
593
|
+
return str.replace(/[A-Z\u00C0-\u00D6\u00D8-\u00DE]/g, (match) => "-" + match.toLowerCase());
|
|
594
|
+
};
|
|
595
|
+
|
|
596
|
+
// directive/value.js
|
|
597
|
+
directive.value = (el, [getValue, setValue], state) => {
|
|
598
|
+
const update = el.type === "text" || el.type === "" ? (value) => el.setAttribute("value", el.value = value == null ? "" : value) : el.tagName === "TEXTAREA" || el.type === "text" || el.type === "" ? (value, from, to) => (from = el.selectionStart, to = el.selectionEnd, el.setAttribute("value", el.value = value == null ? "" : value), from && el.setSelectionRange(from, to)) : el.type === "checkbox" ? (value) => (el.checked = value, attr(el, "checked", value)) : el.type === "select-one" ? (value) => {
|
|
599
|
+
for (let option in el.options)
|
|
600
|
+
option.removeAttribute("selected");
|
|
601
|
+
el.value = value;
|
|
602
|
+
el.selectedOptions[0]?.setAttribute("selected", "");
|
|
603
|
+
} : (value) => el.value = value;
|
|
604
|
+
const handleChange = el.type === "checkbox" ? (e) => setValue(state, el.checked) : (e) => setValue(state, el.value);
|
|
605
|
+
el.addEventListener("input", handleChange);
|
|
606
|
+
el.addEventListener("change", handleChange);
|
|
607
|
+
return effect(() => update(getValue(state)));
|
|
608
|
+
};
|
|
609
|
+
directive.value.parse = (expr) => {
|
|
610
|
+
let evaluate = [parse(expr)];
|
|
611
|
+
try {
|
|
612
|
+
evaluate.push(parse(`${expr}=arguments[1];`));
|
|
613
|
+
} catch (e) {
|
|
614
|
+
}
|
|
615
|
+
return evaluate;
|
|
616
|
+
};
|
|
617
|
+
|
|
618
|
+
// directive/fx.js
|
|
619
|
+
directive.fx = (el, evaluate, state) => {
|
|
620
|
+
return effect(() => evaluate(state));
|
|
621
|
+
};
|
|
622
|
+
|
|
623
|
+
// sprae.js
|
|
624
|
+
sprae.use(ulive_es_exports);
|
|
625
|
+
sprae.use({ compile: (expr) => sprae.constructor(`with (arguments[0]) { return ${expr} };`) });
|
|
626
|
+
var sprae_default = sprae;
|
|
627
|
+
if (document?.currentScript) {
|
|
628
|
+
window.sprae = sprae;
|
|
629
|
+
if (document.currentScript.hasAttribute("init"))
|
|
630
|
+
sprae(document.documentElement);
|
|
631
|
+
}
|
|
632
|
+
})();
|