@rojaebl/supa-store 0.0.0-stage → 0.7.2

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.
Files changed (57) hide show
  1. package/LICENSE +21 -0
  2. package/README.md +707 -3
  3. package/dist/derived.d.ts +9 -0
  4. package/dist/derived.js +103 -0
  5. package/dist/index.d.ts +123 -0
  6. package/dist/index.js +271 -0
  7. package/dist/label.d.ts +5 -0
  8. package/dist/label.js +38 -0
  9. package/dist/mutation.d.ts +46 -0
  10. package/dist/mutation.js +131 -0
  11. package/dist/query.d.ts +184 -0
  12. package/dist/query.js +301 -0
  13. package/dist/react.d.ts +29 -0
  14. package/dist/react.js +36 -0
  15. package/dist/refetch.d.ts +25 -0
  16. package/dist/refetch.js +117 -0
  17. package/dist/resourceHook.d.ts +57 -0
  18. package/dist/resourceHook.js +292 -0
  19. package/dist/rpc/client.d.ts +65 -0
  20. package/dist/rpc/client.js +226 -0
  21. package/dist/rpc/error.d.ts +7 -0
  22. package/dist/rpc/error.js +13 -0
  23. package/dist/rpc/framing.d.ts +4 -0
  24. package/dist/rpc/framing.js +64 -0
  25. package/dist/rpc/index.d.ts +4 -0
  26. package/dist/rpc/index.js +4 -0
  27. package/dist/rpc/session.d.ts +18 -0
  28. package/dist/rpc/session.js +120 -0
  29. package/dist/rpc/transport.d.ts +26 -0
  30. package/dist/rpc/transport.js +122 -0
  31. package/dist/server/core.d.ts +72 -0
  32. package/dist/server/core.js +367 -0
  33. package/dist/server/index.d.ts +2 -0
  34. package/dist/server/index.js +2 -0
  35. package/dist/server/node.d.ts +12 -0
  36. package/dist/server/node.js +240 -0
  37. package/dist/server/sse.d.ts +10 -0
  38. package/dist/server/sse.js +25 -0
  39. package/dist/server/web.d.ts +8 -0
  40. package/dist/server/web.js +147 -0
  41. package/dist/stream/client.d.ts +43 -0
  42. package/dist/stream/client.js +397 -0
  43. package/dist/stream/hook.d.ts +9 -0
  44. package/dist/stream/hook.js +70 -0
  45. package/dist/stream/index.d.ts +53 -0
  46. package/dist/stream/index.js +43 -0
  47. package/dist/stream/protocol.d.ts +105 -0
  48. package/dist/stream/protocol.js +32 -0
  49. package/dist/track.d.ts +19 -0
  50. package/dist/track.js +25 -0
  51. package/package.json +104 -3
  52. package/tools/decline-loader.cjs +8 -0
  53. package/tools/definition.cjs +14 -0
  54. package/tools/next.d.mts +2 -0
  55. package/tools/next.mjs +30 -0
  56. package/tools/vite.d.mts +3 -0
  57. package/tools/vite.mjs +43 -0
package/dist/react.js ADDED
@@ -0,0 +1,36 @@
1
+ "use client";
2
+ import { useRef, useSyncExternalStore } from "react";
3
+ import { DISPOSE, getStore, pickFrom, USE } from "./index.js";
4
+ export function useStore(handle, ...args) {
5
+ const store = getStore(handle);
6
+ // [USE] 갈래와 pick 갈래는 store 마다 늘 같은 쪽이라 훅 순서가 바뀌지 않는다
7
+ if (USE in store.getInitialState()) {
8
+ // 다시 지으면(Store.override · Store.reset) 상태 객체가 바뀐다 — 구독해 두어야 새 상태의 [USE] 로 다시 그린다
9
+ const state = useSyncExternalStore(store.subscribe, store.getState, store.getState);
10
+ return state[USE](...args);
11
+ }
12
+ const options = args[0] ?? {};
13
+ const cache = useRef(null);
14
+ const snapshot = (state) => {
15
+ if (!options.pick && !options.omit)
16
+ return state;
17
+ // 핸들이나 고른 칸 이름이 바뀌었으면 앞 결과를 쓰지 않는다
18
+ const last = cache.current;
19
+ const names = options.pick ? [...options.pick] : Object.keys(state).filter((n) => !options.omit.includes(n));
20
+ const prev = last && last.handle === handle && last.names.length === names.length && names.every((n, i) => n === last.names[i])
21
+ ? last
22
+ : null;
23
+ if (prev?.state === state)
24
+ return prev.out;
25
+ const raw = names.map((n) => state[n]);
26
+ // pickFrom 은 함수 칸을 묶어 매번 새 함수를 만든다 — 묶기 전 값끼리 견줘야 같다고 본다
27
+ if (prev && raw.every((v, i) => Object.is(v, prev.raw[i]))) {
28
+ cache.current = { ...prev, state };
29
+ return prev.out;
30
+ }
31
+ const out = pickFrom(state, { pick: names });
32
+ cache.current = { handle, state, names, raw, out };
33
+ return out;
34
+ };
35
+ return useSyncExternalStore(store.subscribe, () => snapshot(store.getState()), () => snapshot(store.getInitialState()));
36
+ }
@@ -0,0 +1,25 @@
1
+ /** 주기 간격(ms). 함수면 args 마다 구한다 — false · undefined 는 정하지 않았다 */
2
+ export type RefetchInterval<A> = number | false | ((args: A) => number | false | undefined);
3
+ /** 함수가 던지면 그 args 는 간격을 정하지 않은 것으로 본다 — 받기가 끝난 자리에서 불려 성공을 거절로 바꾸지 않게 */
4
+ export declare const valueOf: <A>(v: RefetchInterval<A> | undefined, args: A) => number | false | undefined;
5
+ export declare function createRefetcher<A>(core: {
6
+ resource: RefetchInterval<A> | undefined;
7
+ load(args: A): Promise<unknown>;
8
+ idOf(args: A): string;
9
+ inflight(args: A): Promise<unknown> | undefined;
10
+ /** 그 args 를 보는 첫 화면이 들어왔다 */
11
+ onWatch?(args: A): void;
12
+ /** 그 args 를 보던 마지막 화면이 빠졌다 */
13
+ onUnwatch?(args: A): void;
14
+ }): {
15
+ /** 화면이 args 를 보기 시작한다 — 풀기 함수를 돌려준다. 마지막 화면이 떠나면 타이머를 걷는다 */
16
+ watch(args: A, screen: RefetchInterval<A> | undefined): () => void;
17
+ /** 칸을 놓았다 — 늘린 정도를 지워 다시 보면 처음 간격부터 */
18
+ forget: (args: A) => void;
19
+ /** 그 args 를 보는 화면이 있는가 */
20
+ watching: (args: A) => boolean;
21
+ /** 화면 간격이 바뀌었다 — 세던 때(from)는 그대로 두고 지금 값으로 다시 건다. 없으면 타이머만 걷힌다 */
22
+ rearm(args: A): void;
23
+ /** 그 args 의 받기가 끝났다(어디서 받았든) — 늘린 정도를 고치고 끝난 때부터 다시 센다 */
24
+ settled(args: A, ok: boolean): void;
25
+ };
@@ -0,0 +1,117 @@
1
+ // 주기적으로 다시 받기 — 자원 하나에 하나. args 하나에 타이머 하나이고, 그 args 를 보는 화면이 있는 동안만 돈다
2
+ // 정의 파일과 함께 서버 쪽에서도 평가되므로 "use client" 를 두지 않는다. 타이머는 화면의 effect 에서만 걸린다
3
+ /** 실패할 때마다 두 배, 기본 간격의 8배까지 */
4
+ const MAX_LEVEL = 3;
5
+ /** 함수가 던지면 그 args 는 간격을 정하지 않은 것으로 본다 — 받기가 끝난 자리에서 불려 성공을 거절로 바꾸지 않게 */
6
+ export const valueOf = (v, args) => {
7
+ try {
8
+ return typeof v === "function" ? v(args) : v;
9
+ }
10
+ catch {
11
+ return undefined;
12
+ }
13
+ };
14
+ const hidden = () => typeof document !== "undefined" && document.visibilityState === "hidden";
15
+ export function createRefetcher(core) {
16
+ const watched = new Map();
17
+ /** 늘린 정도 — args 마다, 보는 화면이 없어도 쥔다. 0 이면 지운다 */
18
+ const levels = new Map();
19
+ /** 자원 값이 숫자면 그것, 아니면 보는 화면들 가운데 가장 짧은 숫자 */
20
+ const baseOf = (w) => {
21
+ const own = valueOf(core.resource, w.args);
22
+ if (typeof own === "number")
23
+ return own;
24
+ const nums = w.screens.map((s) => valueOf(s, w.args)).filter((v) => typeof v === "number");
25
+ return nums.length ? Math.min(...nums) : undefined;
26
+ };
27
+ const poll = (id) => {
28
+ const w = watched.get(id);
29
+ if (!w)
30
+ return;
31
+ w.timer = undefined;
32
+ if (hidden())
33
+ w.due = true;
34
+ // 끝나면 load 가 settled 를 불러 다시 건다
35
+ else
36
+ core.load(w.args).catch(() => { });
37
+ };
38
+ /** 지금 값으로 타이머를 다시 건다. 받는 중이면 끝날 때 settled 가 건다 */
39
+ const arm = (id, w) => {
40
+ clearTimeout(w.timer);
41
+ w.timer = undefined;
42
+ const base = baseOf(w);
43
+ if (base === undefined || w.due || core.inflight(w.args))
44
+ return;
45
+ const delay = base * 2 ** (levels.get(id) ?? 0);
46
+ w.timer = setTimeout(() => poll(id), Math.max(0, w.from + delay - Date.now()));
47
+ };
48
+ const onVisible = () => {
49
+ if (hidden())
50
+ return;
51
+ watched.forEach((w, id) => {
52
+ if (!w.due)
53
+ return;
54
+ w.due = false;
55
+ poll(id);
56
+ });
57
+ };
58
+ return {
59
+ /** 화면이 args 를 보기 시작한다 — 풀기 함수를 돌려준다. 마지막 화면이 떠나면 타이머를 걷는다 */
60
+ watch(args, screen) {
61
+ const id = core.idOf(args);
62
+ let w = watched.get(id);
63
+ const first = !w;
64
+ if (!w) {
65
+ if (watched.size === 0 && typeof document !== "undefined")
66
+ document.addEventListener("visibilitychange", onVisible);
67
+ watched.set(id, (w = { args, screens: [], from: Date.now(), due: false }));
68
+ }
69
+ const entry = w;
70
+ // 같은 값이 둘이면 풀 때 어느 것을 지워도 같다
71
+ entry.screens.push(screen);
72
+ arm(id, entry);
73
+ if (first)
74
+ core.onWatch?.(args);
75
+ let done = false;
76
+ return () => {
77
+ if (done)
78
+ return;
79
+ done = true;
80
+ entry.screens.splice(entry.screens.indexOf(screen), 1);
81
+ if (entry.screens.length > 0)
82
+ return arm(id, entry);
83
+ clearTimeout(entry.timer);
84
+ watched.delete(id);
85
+ if (watched.size === 0 && typeof document !== "undefined")
86
+ document.removeEventListener("visibilitychange", onVisible);
87
+ core.onUnwatch?.(entry.args);
88
+ };
89
+ },
90
+ /** 칸을 놓았다 — 늘린 정도를 지워 다시 보면 처음 간격부터 */
91
+ forget: (args) => void levels.delete(core.idOf(args)),
92
+ /** 그 args 를 보는 화면이 있는가 */
93
+ watching: (args) => watched.has(core.idOf(args)),
94
+ /** 화면 간격이 바뀌었다 — 세던 때(from)는 그대로 두고 지금 값으로 다시 건다. 없으면 타이머만 걷힌다 */
95
+ rearm(args) {
96
+ const id = core.idOf(args);
97
+ const w = watched.get(id);
98
+ if (w)
99
+ arm(id, w);
100
+ },
101
+ /** 그 args 의 받기가 끝났다(어디서 받았든) — 늘린 정도를 고치고 끝난 때부터 다시 센다 */
102
+ settled(args, ok) {
103
+ const id = core.idOf(args);
104
+ const level = ok ? 0 : Math.min((levels.get(id) ?? 0) + 1, MAX_LEVEL);
105
+ if (level)
106
+ levels.set(id, level);
107
+ else
108
+ levels.delete(id);
109
+ const w = watched.get(id);
110
+ if (!w)
111
+ return;
112
+ w.from = Date.now();
113
+ w.due = false;
114
+ arm(id, w);
115
+ },
116
+ };
117
+ }
@@ -0,0 +1,57 @@
1
+ import type { MutationView, PlaceholderData, Status } from "./query.js";
2
+ import { type MutationChannel, type MutationFn, message } from "./mutation.js";
3
+ import { type RefetchInterval } from "./refetch.js";
4
+ export { message };
5
+ type Fn = (...args: any[]) => any;
6
+ type CellView<D> = {
7
+ data: D | undefined;
8
+ status: Status;
9
+ error: string | null;
10
+ isFetching: boolean;
11
+ };
12
+ /** createResource 가 훅에 넘기는 안쪽 */
13
+ export interface ResourceCore<A, D> {
14
+ /** stale 은 보지 않는 동안 무효화된 칸 — 화면이 보기 시작하면 곧바로 다시 받는다 */
15
+ cellOf(args: A | undefined): {
16
+ view: CellView<D>;
17
+ request?: Promise<D>;
18
+ stale?: boolean;
19
+ };
20
+ load(args: A | undefined, force?: boolean): Promise<D>;
21
+ subscribe(listener: () => void): () => void;
22
+ idOf(args: A | undefined): string;
23
+ query: ((args: A) => Promise<D>) | undefined;
24
+ auto: boolean;
25
+ /** 자원의 select — 화면에 줄 때만 거친다 */
26
+ select: ((data: D, args: A) => unknown) | undefined;
27
+ /** 자원의 자리 채우기 — 화면의 것보다 먼저 구한다 */
28
+ placeholderData: PlaceholderData<A, D> | undefined;
29
+ /** 바꾸기마다 자원이 쥔 상태 — call 은 부를 수 있는 바꾸기, channel 은 그 구독 단위 */
30
+ mutations: Record<string, {
31
+ call: MutationFn<Fn>;
32
+ channel: MutationChannel;
33
+ }>;
34
+ names: string[];
35
+ /** 화면이 args 를 보기 시작한다(주기 받기) — 풀기 함수를 돌려준다 */
36
+ watch(args: A | undefined, screen: RefetchInterval<A | undefined>): () => void;
37
+ /** 화면 간격이 바뀌었다 — 그 args 의 타이머를 지금 값으로 다시 건다 */
38
+ rearm(args: A | undefined): void;
39
+ }
40
+ export declare const QUERY_FIELDS: string[];
41
+ export declare const IDLE: CellView<never>;
42
+ export declare const noop: () => void;
43
+ export declare const subscribeNone: () => () => void;
44
+ export declare const plain: (x: unknown) => x is object;
45
+ /** 겉 한 겹 견주기 — 칸마다 Object.is, 둘 다 배열이거나 둘 다 보통 객체면 그 겉 칸도 Object.is. 깊이 견주지 않는다 */
46
+ export declare function same(a: unknown, b: unknown): boolean;
47
+ export declare function makeResourceHook<A, D>(core: ResourceCore<A, D>): (options?: object) => unknown;
48
+ /** 바꾸기 하나의 자원이 쥔 상태를 읽는다 — 같은 자원을 보는 화면들이 같은 칸을 본다. 늦은 응답은 바꾸기 안에서 이미 걸러진다 */
49
+ export declare function useSharedMutation(m: {
50
+ call: MutationFn<Fn>;
51
+ channel: MutationChannel;
52
+ }, on?: boolean): MutationView<Fn>;
53
+ /**
54
+ * 바꾸기 하나의 화면별 상태. 화면 안에서 요청 차례를 세어 늦게 온 응답을 버린다.
55
+ * more 는 같은 차례 세기로 다른 부르기를 돌리는 칸을 더한다(연결 명령의 retry)
56
+ */
57
+ export declare function useMutation(fn: Fn, more?: (run: (call: () => unknown) => Promise<unknown>) => object): MutationView<Fn>;
@@ -0,0 +1,292 @@
1
+ // 자원 훅 — 정의 파일과 함께 서버 쪽에서도 평가되므로 "use client" 를 두지 않고 React 를 이름공간으로 가져온다
2
+ import * as React from "react";
3
+ import { message } from "./mutation.js";
4
+ import { track } from "./track.js";
5
+ import { valueOf } from "./refetch.js";
6
+ export { message };
7
+ export const QUERY_FIELDS = ["data", "status", "error", "isPlaceholderData", "isFetching", "refetch"];
8
+ export const IDLE = { data: undefined, status: "idle", error: null, isFetching: false };
9
+ export const noop = () => { };
10
+ export const subscribeNone = () => noop;
11
+ const IDLE_MUTATION = { inflight: [], optimistic: [], pending: false, error: null, data: undefined };
12
+ const idleSnapshot = () => IDLE_MUTATION;
13
+ export const plain = (x) => {
14
+ if (typeof x !== "object" || x === null)
15
+ return false;
16
+ const proto = Object.getPrototypeOf(x);
17
+ return proto === Object.prototype || proto === null;
18
+ };
19
+ /** 겉 한 겹 견주기 — 칸마다 Object.is, 둘 다 배열이거나 둘 다 보통 객체면 그 겉 칸도 Object.is. 깊이 견주지 않는다 */
20
+ export function same(a, b) {
21
+ if (Object.is(a, b))
22
+ return true;
23
+ // Date · Map · 클래스 인스턴스는 Object.keys 가 값을 보이지 않으므로 Object.is 로만 본다
24
+ if (!(Array.isArray(a) && Array.isArray(b)) && !(plain(a) && plain(b)))
25
+ return false;
26
+ const keys = Object.keys(a);
27
+ return keys.length === Object.keys(b).length && keys.every((k) => k in b && Object.is(a[k], b[k]));
28
+ }
29
+ /** 자원 → 화면 차례로 구한다. 함수의 셋째 인자는 keepPreviousData 꼴 1 에 목록 꼴인지 알린다 */
30
+ function fill(sources, args, prev, list) {
31
+ for (const p of sources) {
32
+ const v = typeof p === "function" ? p(args, prev, list) : p;
33
+ if (v !== undefined)
34
+ return v;
35
+ }
36
+ return undefined;
37
+ }
38
+ export function makeResourceHook(core) {
39
+ const { cellOf, load, subscribe, idOf, query, auto, select, placeholderData, mutations, names, watch, rearm } = core;
40
+ return function useResource(options) {
41
+ // 하나 꼴은 길이 1 목록처럼 다루고 마지막에 푼다 — 두 꼴이 같은 훅을 같은 차례로 부른다
42
+ const list = Array.isArray(options?.args);
43
+ const argsList = (list ? options.args : [options?.args]);
44
+ const shown = options?.pick ?? [...QUERY_FIELDS, ...(list ? [] : names)].filter((n) => !options?.omit?.includes(n));
45
+ const fields = shown.filter((n) => QUERY_FIELDS.includes(n));
46
+ // 조회 칸을 하나도 고르지 않았거나, 인자가 필요한데 없으면 그 항목은 받지도 구독하지도 않는다
47
+ const active = argsList.map((a) => query !== undefined && fields.length > 0 && !(query.length > 0 && a === undefined));
48
+ const ids = argsList.map(idOf);
49
+ // 렌더마다 새 args 배열이어도 칸 id 를 이은 글자가 같으면 같은 것으로 본다
50
+ const activeKey = ids.filter((_, i) => active[i]).join("\n");
51
+ const last = React.useRef(null);
52
+ // 바로 전 렌더에 보이던 값 — 고른 칸이 바뀌어도 last 와 달리 버리지 않는다
53
+ const prevShown = React.useRef([]);
54
+ const snapshot = () => {
55
+ const prev = last.current?.core === core && last.current.fields === fields.join() ? last.current : null;
56
+ const byId = new Map();
57
+ const items = argsList.map((a, i) => {
58
+ const id = ids[i];
59
+ const on = active[i];
60
+ const kept = byId.get(id);
61
+ if (kept)
62
+ return kept.out;
63
+ const cell = on ? cellOf(a) : undefined;
64
+ const { data: got, status, error } = cell?.view ?? IDLE;
65
+ // 낡은 칸은 이 화면이 보기 시작하면(watch 효과) 다시 받는다 — 첫 판부터 받는 중으로 보인다. 칸의 값은 건드리지 않는다
66
+ const isFetching = cell ? cell.view.isFetching || (cell.stale === true && status !== "idle") : false;
67
+ const before = prev?.byId.get(id);
68
+ const screen = options?.select;
69
+ // 받는 항목이 받은 값이 없으면(받는 중 · 실패) 자리를 채운다. 앞에도 채웠고 화면 placeholderData 가 그대로면 그 값을 쓴다 —
70
+ // 그려진 뒤 prev 가 바뀌어도 다시 구하지 않아야 새 객체를 짓는 함수가 끝없이 다시 그리지 않는다
71
+ let raw = got;
72
+ let filled;
73
+ if (got === undefined && on) {
74
+ filled = { with: options?.placeholderData };
75
+ raw =
76
+ before?.filled && before.raw !== undefined && before.filled.with === filled.with
77
+ ? before.raw
78
+ : fill([placeholderData, filled.with], a, list ? prevShown.current : prevShown.current.slice(0, 1), list);
79
+ }
80
+ // 자원 select → 화면 select. getSnapshot 은 렌더마다 여러 번 불리므로 받은 값과 화면 select 가 그대로면 앞 결과를 쓴다 —
81
+ // 안 그러면 매번 새 객체를 만드는 select 가 스냅숏을 흔들어 끝없이 다시 그린다. 자원 select 는 core 와 함께 같다
82
+ // 자원 select 가 읽은 바꾸기 칸도 그대로여야 한다 — 겹이 바뀌면 select 만 다시 돈다(정의 · 캐시 · 받기는 그대로)
83
+ let data = raw;
84
+ let reads = [];
85
+ if (before &&
86
+ Object.is(before.raw, raw) &&
87
+ before.screen === screen &&
88
+ before.reads.every(([c, s]) => c.snapshot() === s)) {
89
+ data = before.data;
90
+ reads = before.reads;
91
+ }
92
+ else {
93
+ if (data !== undefined && select) {
94
+ const run = track(() => select(data, a));
95
+ data = run.value;
96
+ reads = run.reads.map((c) => [c, c.snapshot()]);
97
+ }
98
+ if (data !== undefined && screen)
99
+ data = screen(data, a);
100
+ }
101
+ const values = {
102
+ data,
103
+ status,
104
+ error,
105
+ isPlaceholderData: filled !== undefined && raw !== undefined,
106
+ isFetching,
107
+ };
108
+ const reuse = before?.on === on && fields.every((f) => f === "refetch" || same(before.out[f], values[f]));
109
+ let out = before?.out;
110
+ if (!reuse) {
111
+ values.refetch = () => (on ? load(a).then(noop, noop) : Promise.resolve());
112
+ out = {};
113
+ for (const f of fields)
114
+ out[f] = values[f];
115
+ }
116
+ byId.set(id, { on, out, raw, screen, data, filled, reads });
117
+ return out;
118
+ });
119
+ const visible = argsList.flatMap((a, i) => {
120
+ const raw = byId.get(ids[i]).raw;
121
+ return raw === undefined ? [] : [{ args: a, data: raw }];
122
+ });
123
+ // 바뀐 항목이 없으면 앞 배열을 그대로 준다 — 다시 그리지 않는다
124
+ if (prev && prev.items.length === items.length && items.every((it, i) => it === prev.items[i])) {
125
+ prev.byId = byId;
126
+ prev.visible = visible;
127
+ return prev.items;
128
+ }
129
+ last.current = { core, fields: fields.join(), items, byId, visible };
130
+ return items;
131
+ };
132
+ // 자원 구독에 더해 적힌 바꾸기 칸도 알린다 — 칸 구독은 아래 효과가 렌더마다 맞추고 이 알림 자리를 부른다
133
+ const notify = React.useRef(null);
134
+ const anyActive = active.some(Boolean);
135
+ const subscribeAll = React.useCallback((listener) => {
136
+ notify.current = listener;
137
+ const off = (anyActive ? subscribe : subscribeNone)(listener);
138
+ return () => {
139
+ off();
140
+ if (notify.current === listener)
141
+ notify.current = null;
142
+ };
143
+ }, [core, anyActive]);
144
+ const items = React.useSyncExternalStore(subscribeAll, snapshot, snapshot);
145
+ // 적힌 칸을 앞과 견주어 빠진 것만 풀고 새 것만 건다. 렌더와 이 효과 사이에 칸이 바뀌었으면 한 번 알린다
146
+ const reading = React.useRef(new Map());
147
+ React.useEffect(() => {
148
+ const want = new Map();
149
+ last.current?.byId.forEach((item) => item.reads.forEach(([c, s]) => want.set(c, s)));
150
+ const map = reading.current;
151
+ map.forEach((stop, c) => want.has(c) || (stop(), map.delete(c)));
152
+ want.forEach((_, c) => map.has(c) || map.set(c, c.subscribe(() => notify.current?.())));
153
+ for (const [c, s] of want)
154
+ if (c.snapshot() !== s)
155
+ return void notify.current?.();
156
+ });
157
+ React.useEffect(() => {
158
+ const map = reading.current;
159
+ return () => {
160
+ map.forEach((stop) => stop());
161
+ map.clear();
162
+ };
163
+ }, []);
164
+ // 화면 간격은 렌더마다 새 함수여도 된다 — 타이머가 걸릴 때 마지막 값을 읽는다
165
+ const interval = React.useRef(options?.refetchInterval);
166
+ // 그려진 뒤에야 prev 를 넘긴다 — 한 렌더 안에서 스냅숏이 여러 번 불려도 모두 같은 앞 렌더를 본다
167
+ React.useEffect(() => {
168
+ prevShown.current = last.current?.visible ?? [];
169
+ interval.current = options?.refetchInterval;
170
+ });
171
+ const seen = React.useRef(null);
172
+ React.useEffect(() => {
173
+ if (!activeKey || !auto)
174
+ return;
175
+ // 이 화면이 다른 칸에서 넘어왔으면(A→B→A) 진행 중인 앞 요청을 나눠 쓰지 않고 새로 받는다
176
+ const before = seen.current;
177
+ seen.current = new Set(activeKey.split("\n"));
178
+ const done = new Set();
179
+ argsList.forEach((a, i) => {
180
+ const id = ids[i];
181
+ if (!active[i] || done.has(id))
182
+ return;
183
+ done.add(id);
184
+ // 하나 꼴의 args 가 바뀐 것만 넘어온 것이다 — 목록에 새로 든 args 는 남이 받는 중인 요청을 나눠 쓴다
185
+ const moved = !list && before !== null && !before.has(id);
186
+ const cell = cellOf(a);
187
+ if (cell.view.status === "ready" || (cell.request && !moved))
188
+ return;
189
+ load(a, moved).catch(noop);
190
+ });
191
+ // 자원을 다시 지으면 core 가 새 객체다 — 새 칸은 idle 이므로 다시 받는다
192
+ }, [activeKey, core]);
193
+ // 주기 받기에 보는 args 를 건다. auto 와 상관없다. 앞과 견주어 빠진 것만 풀고 새 것만 건다 — 그대로인 args 의 타이머는 이어 간다
194
+ const watching = React.useRef(new Map());
195
+ React.useEffect(() => {
196
+ const want = new Map();
197
+ argsList.forEach((a, i) => active[i] && want.set(ids[i], a));
198
+ const map = watching.current;
199
+ map.forEach((stop, id) => want.has(id) || (stop(), map.delete(id)));
200
+ const screen = (a) => valueOf(interval.current, a);
201
+ want.forEach((a, id) => map.has(id) || map.set(id, watch(a, screen)));
202
+ }, [activeKey, core]);
203
+ // 떠나거나 자원을 다시 지으면 모두 푼다 — 정리가 위 효과보다 먼저 돌므로 다시 지을 때 비운 map 에 새 자원으로 다시 건다
204
+ React.useEffect(() => {
205
+ const map = watching.current;
206
+ return () => {
207
+ map.forEach((stop) => stop());
208
+ map.clear();
209
+ };
210
+ }, [core]);
211
+ // args 는 그대로이고 화면 간격만 바뀌면 다시 건다 — 위 효과는 args 가 바뀔 때만 돈다
212
+ const intervalKey = argsList.map((a, i) => (active[i] ? `${ids[i]}=${valueOf(options?.refetchInterval, a)}` : "")).join("\n");
213
+ const armed = React.useRef(intervalKey);
214
+ React.useEffect(() => {
215
+ if (armed.current === intervalKey)
216
+ return;
217
+ armed.current = intervalKey;
218
+ argsList.forEach((a, i) => active[i] && rearm(a));
219
+ }, [intervalKey]);
220
+ // 바꾸기마다 훅을 정해진 차례로 부른다 — 꼴 · 고르기와 상관없이 훅 순서가 같다. 보이지 않는 칸은 구독하지 않는다
221
+ const views = {};
222
+ for (const name of names)
223
+ views[name] = useSharedMutation(mutations[name], !list && shown.includes(name));
224
+ if (list)
225
+ return items;
226
+ const item = items[0];
227
+ // 바꾸기 칸은 하나 꼴에서만 붙인다. ponytail: 바꾸기를 고르면 바꾸기 칸이 렌더마다 새 객체라 결과도 새 객체다
228
+ if (!shown.some((n) => names.includes(n)))
229
+ return item;
230
+ const out = {};
231
+ for (const name of shown)
232
+ out[name] = name in item ? item[name] : views[name];
233
+ return out;
234
+ };
235
+ }
236
+ /** 바꾸기 하나의 자원이 쥔 상태를 읽는다 — 같은 자원을 보는 화면들이 같은 칸을 본다. 늦은 응답은 바꾸기 안에서 이미 걸러진다 */
237
+ export function useSharedMutation(m, on = true) {
238
+ const { call, channel } = m;
239
+ // 보이지 않는 칸은 구독하지 않고 고정된 스냅숏을 준다 — 바뀌어도 이 화면을 다시 그리지 않는다. 훅 순서는 그대로다
240
+ const snap = React.useSyncExternalStore(on ? channel.subscribe : subscribeNone, on ? channel.snapshot : idleSnapshot, on ? channel.snapshot : idleSnapshot);
241
+ return {
242
+ ...snap,
243
+ mutate(...args) {
244
+ call(...args).catch(noop);
245
+ },
246
+ mutateAsync: (...args) => call(...args),
247
+ reset: () => call.reset(),
248
+ };
249
+ }
250
+ /**
251
+ * 바꾸기 하나의 화면별 상태. 화면 안에서 요청 차례를 세어 늦게 온 응답을 버린다.
252
+ * more 는 같은 차례 세기로 다른 부르기를 돌리는 칸을 더한다(연결 명령의 retry)
253
+ */
254
+ export function useMutation(fn, more) {
255
+ const [state, setState] = React.useState({
256
+ pending: false,
257
+ error: null,
258
+ data: undefined,
259
+ });
260
+ const seq = React.useRef(0);
261
+ // 밀린 호출은 칸을 건드리지 않지만 자기 Promise 는 자기 결과로 끝난다
262
+ const run = async (call) => {
263
+ const mine = ++seq.current;
264
+ setState((s) => ({ ...s, pending: true, error: null }));
265
+ try {
266
+ const data = await call();
267
+ if (mine === seq.current)
268
+ setState({ pending: false, error: null, data });
269
+ return data;
270
+ }
271
+ catch (e) {
272
+ if (mine === seq.current)
273
+ setState((s) => ({ ...s, pending: false, error: message(e) }));
274
+ throw e;
275
+ }
276
+ };
277
+ return {
278
+ ...state,
279
+ // 연결 명령의 화면별 상태는 날아가는 호출 목록을 세지 않는다
280
+ inflight: [],
281
+ optimistic: [],
282
+ mutate(...args) {
283
+ run(() => fn(...args)).catch(noop);
284
+ },
285
+ mutateAsync: (...args) => run(() => fn(...args)),
286
+ reset() {
287
+ seq.current += 1;
288
+ setState({ pending: false, error: null, data: undefined });
289
+ },
290
+ ...more?.(run),
291
+ };
292
+ }
@@ -0,0 +1,65 @@
1
+ import { DISPOSE } from "../index.js";
2
+ import { type ClientView } from "../stream/client.js";
3
+ import type { Transport } from "./transport.js";
4
+ type Fn = (params: any) => unknown;
5
+ /** 돌려주는 객체가 쓰는 이름 — 요청 · 알림 이름으로 쓸 수 없다 */
6
+ type Reserved = "request" | "notify" | "view" | "subscribe" | "close";
7
+ /** onConnect 에 넘어오는 rpc — 준비 문을 거치지 않고 곧바로 보낸다 */
8
+ export interface ConnectRpc {
9
+ request(method: string, params?: unknown): Promise<unknown>;
10
+ notify(method: string, params?: unknown): void;
11
+ }
12
+ /** 요청의 타입은 셋째 타입 인자로, method 와 제한 시간은 requests 에 — 이름마다 한 칸이 있어야 한다(없으면 타입 오류)
13
+ * 보낼 알림의 params 타입은 넷째 타입 인자로, method 는 notifications 에 — 같은 규칙이다 */
14
+ export type JsonRpcOptions<V, N, Cmd, Out> = {
15
+ /** 처음 열 때와 다시 이을 때마다 부른다. 던지거나 거절하면 그 문구를 error 에 싣고 다시 부른다 */
16
+ connect: () => Transport | Promise<Transport>;
17
+ /** 열린 뒤 상대와 맞추고 이어 갈 값을 돌려준다. 생략하면 곧바로 준비되고 값은 마지막 값 그대로 */
18
+ onConnect?: (last: V | undefined, rpc: ConnectRpc) => V | Promise<V>;
19
+ reduce?: (value: V, note: N) => V;
20
+ /** 상대가 묻는 요청 — params 를 펼치지 않고 하나로 받는다 */
21
+ handlers?: Record<string, (params: any) => unknown>;
22
+ /** 「응답 지연」으로 끝낸 요청을 상대에게 알리는 알림 */
23
+ cancel?: (id: number) => {
24
+ method: string;
25
+ params?: unknown;
26
+ };
27
+ /** 기본 30초 */
28
+ timeout?: number;
29
+ } & (keyof Cmd extends never ? {
30
+ requests?: Record<string, never>;
31
+ } : {
32
+ requests: {
33
+ [K in keyof Cmd]: K extends Reserved ? never : {
34
+ method: string;
35
+ timeout?: number;
36
+ };
37
+ };
38
+ }) & (keyof Out extends never ? {
39
+ notifications?: Record<string, never>;
40
+ } : {
41
+ notifications: {
42
+ [K in keyof Out]: K extends Reserved ? never : string;
43
+ };
44
+ });
45
+ export type JsonRpc<V, Cmd, Out> = {
46
+ /** 이름 붙지 않은 요청 — 준비 전이면 준비를 기다린다 */
47
+ request(method: string, params?: unknown): Promise<unknown>;
48
+ /** 준비 전이면 버리고 false */
49
+ notify(method: string, params?: unknown): boolean;
50
+ /** 바뀌지 않았으면 같은 객체 */
51
+ view(): ClientView<V>;
52
+ subscribe(fn: () => void): () => void;
53
+ /** 통로를 닫고 다시 잇지 않는다 */
54
+ close(): void;
55
+ [DISPOSE](): void;
56
+ } & {
57
+ [K in keyof Cmd]: (...params: Parameters<Extract<Cmd[K], Fn>>) => Promise<Awaited<ReturnType<Extract<Cmd[K], Fn>>>>;
58
+ } & {
59
+ [K in keyof Out]: (params: Out[K]) => boolean;
60
+ };
61
+ export declare function createJsonRpc<V, N extends {
62
+ method: string;
63
+ params?: unknown;
64
+ } = never, Cmd extends Record<keyof Cmd, Fn> = {}, Out extends Record<keyof Out, unknown> = {}>(o: JsonRpcOptions<V, N, Cmd, Out>): JsonRpc<V, Cmd, Out>;
65
+ export {};