@rojaebl/supa-store 0.0.0-stage → 0.7.1

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 +692 -3
  3. package/dist/derived.d.ts +9 -0
  4. package/dist/derived.js +103 -0
  5. package/dist/index.d.ts +94 -0
  6. package/dist/index.js +220 -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 +49 -6
  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
@@ -0,0 +1,9 @@
1
+ import { type Derived } from "./index.js";
2
+ /**
3
+ * 다른 store 를 ctx 로 읽어 값을 짓는 상태 — `const x = createStore<Derived<T>>((_s, _g, ctx) => createDerived((prev) => …))`.
4
+ *
5
+ * compute 는 계산 공간에서 돈다: 그 안에서 ctx 로 읽은 store(다른 store 의 함수가 자기 ctx 로 읽은 것까지)가 바뀌면
6
+ * 다시 돈다. 구독자가 없으면 따라가지 않고, 꺼낼 때 읽은 것을 견주어 바뀌었으면 그 자리에서 다시 짓는다.
7
+ * 결과가 Object.is 로 앞과 같으면 구독자를 깨우지 않는다. prev 는 앞 결과다(처음이면 undefined).
8
+ */
9
+ export declare function createDerived<T>(compute: (prev: T | undefined) => T): Derived<T>;
@@ -0,0 +1,103 @@
1
+ // 파생 store — 계산 공간(track)에서 다른 store 를 읽어 값을 짓고, 읽은 것이 바뀌면 다시 짓는다. 훅은 [USE] 안에서만 부른다
2
+ import { useSyncExternalStore } from "react";
3
+ import { DISPOSE, USE } from "./index.js";
4
+ import { DERIVED, track } from "./track.js";
5
+ /**
6
+ * 다른 store 를 ctx 로 읽어 값을 짓는 상태 — `const x = createStore<Derived<T>>((_s, _g, ctx) => createDerived((prev) => …))`.
7
+ *
8
+ * compute 는 계산 공간에서 돈다: 그 안에서 ctx 로 읽은 store(다른 store 의 함수가 자기 ctx 로 읽은 것까지)가 바뀌면
9
+ * 다시 돈다. 구독자가 없으면 따라가지 않고, 꺼낼 때 읽은 것을 견주어 바뀌었으면 그 자리에서 다시 짓는다.
10
+ * 결과가 Object.is 로 앞과 같으면 구독자를 깨우지 않는다. prev 는 앞 결과다(처음이면 undefined).
11
+ */
12
+ export function createDerived(compute) {
13
+ let value;
14
+ let has = false;
15
+ /** 마지막 계산이 읽은 채널과 그때의 스냅숏 */
16
+ let reads = [];
17
+ let computing = false;
18
+ const listeners = new Set();
19
+ /** 구독자가 있는 동안 건 채널 구독 — 채널 → 푸는 함수 */
20
+ const held = new Map();
21
+ /** 구독자에게 마지막으로 알린 값 — 알림은 이것과 견준다(get 이 먼저 다시 지었어도 알림을 잃지 않는다) */
22
+ let shown = null;
23
+ const fresh = () => has && reads.every(([c, s]) => Object.is(c.snapshot(), s));
24
+ const run = () => {
25
+ if (computing)
26
+ throw new Error("파생 store 가 계산 중에 자기 자신을 읽었다");
27
+ computing = true;
28
+ try {
29
+ const r = track(() => compute(has ? value : undefined));
30
+ reads = r.reads.map((c) => [c, c.snapshot()]);
31
+ value = r.value;
32
+ has = true;
33
+ }
34
+ finally {
35
+ computing = false;
36
+ }
37
+ };
38
+ /** 걸어 둔 구독을 마지막 계산이 읽은 채널에 맞춘다 — 빠진 것만 풀고 새 것만 건다 */
39
+ const hold = () => {
40
+ const want = new Set(reads.map(([c]) => c));
41
+ held.forEach((stop, c) => want.has(c) || (stop(), held.delete(c)));
42
+ for (const c of want) {
43
+ if (held.has(c))
44
+ continue;
45
+ // 채널마다 새 함수를 넘긴다 — 여러 채널이 한 listeners 를 나눠 써도(자원 칸들) 한 칸을 풀 때 다른 칸의 구독이 빠지지 않는다
46
+ const off = c.subscribe(() => changed());
47
+ const unwatch = c.watch?.();
48
+ held.set(c, () => (off(), unwatch?.()));
49
+ }
50
+ };
51
+ const release = () => {
52
+ held.forEach((stop) => stop());
53
+ held.clear();
54
+ shown = null;
55
+ };
56
+ /** 낡았으면 다시 짓고 구독을 맞춘다 */
57
+ const refresh = () => {
58
+ if (fresh())
59
+ return;
60
+ run();
61
+ if (listeners.size > 0)
62
+ hold();
63
+ };
64
+ function changed() {
65
+ if (listeners.size === 0)
66
+ return;
67
+ refresh();
68
+ if (shown !== null && Object.is(shown.value, value))
69
+ return;
70
+ shown = { value: value };
71
+ listeners.forEach((l) => l());
72
+ }
73
+ const get = () => {
74
+ if (computing)
75
+ throw new Error("파생 store 가 계산 중에 자기 자신을 읽었다");
76
+ // 구독 중이어도 읽은 것이 바뀌었으면 여기서 다시 짓는다 — 알림 차례에 따라 중간값을 보이지 않게
77
+ refresh();
78
+ return value;
79
+ };
80
+ const subscribe = (listener) => {
81
+ if (listeners.size === 0) {
82
+ listeners.add(listener);
83
+ refresh();
84
+ hold();
85
+ shown = { value: value };
86
+ }
87
+ else
88
+ listeners.add(listener);
89
+ return () => {
90
+ listeners.delete(listener);
91
+ if (listeners.size === 0)
92
+ release();
93
+ };
94
+ };
95
+ const channel = { subscribe, snapshot: get };
96
+ return {
97
+ get,
98
+ subscribe,
99
+ [USE]: () => useSyncExternalStore(subscribe, get, get),
100
+ [DISPOSE]: release,
101
+ [DERIVED]: channel,
102
+ };
103
+ }
@@ -0,0 +1,94 @@
1
+ import { DERIVED, type Channel } from "./track.js";
2
+ export { DERIVED };
3
+ /** 상태에 이 표식으로 함수를 두면 useStore 가 꺼내기를 그 함수에 맡긴다 — 그 함수는 훅이다 */
4
+ export declare const USE: unique symbol;
5
+ /** 상태 객체에 `[DISPOSE]: () => void` 가 있으면 그 store 를 다시 짓기 직전과 disposeStores 에서 부른다 */
6
+ export declare const DISPOSE: unique symbol;
7
+ export type SetState<T> = (partial: Partial<T> | ((now: T) => Partial<T>)) => void;
8
+ export type GetState<T> = () => T;
9
+ export interface StoreApi<T> {
10
+ getState(): T;
11
+ getInitialState(): T;
12
+ setState: SetState<T>;
13
+ subscribe(listener: () => void): () => void;
14
+ }
15
+ declare const STATE: unique symbol;
16
+ /** createStore 가 돌려주는 핸들 — store 를 가리키는 표지일 뿐이다. 읽고 쓰는 길은 getStore(handle) 이다 */
17
+ export interface Store<S> {
18
+ readonly [STATE]?: S;
19
+ }
20
+ /** 한 store 상태의 칸 이름 */
21
+ export type Names<S> = keyof S & string;
22
+ /** 고를 칸(pick) 또는 뺄 칸(omit) — 둘 중 하나만 */
23
+ export type PickOptions<S, N extends Names<S> = Names<S>> = {
24
+ pick: readonly N[];
25
+ omit?: never;
26
+ } | {
27
+ omit: readonly N[];
28
+ pick?: never;
29
+ };
30
+ /** 고른 결과의 타입 — pick 이면 그 칸만, omit 이면 그 칸을 뺀 나머지 */
31
+ export type Picked<S, O> = O extends {
32
+ pick: readonly (infer N)[];
33
+ } ? Pick<S, N & keyof S> : O extends {
34
+ omit: readonly (infer N)[];
35
+ } ? Omit<S, N & keyof S> : S;
36
+ /** 파생 store 의 상태 — createDerived(supa-store/query)가 짓는다. useStore · ctx 로 꺼내면 값 T 를 준다 */
37
+ export interface Derived<T> {
38
+ /** 지금 값. 구독자가 없으면 그 자리에서 계산한다(읽은 것이 그대로면 앞 결과) */
39
+ get(): T;
40
+ subscribe(listener: () => void): () => void;
41
+ [USE](): T;
42
+ [DISPOSE](): void;
43
+ [DERIVED]: Channel;
44
+ }
45
+ /** ctx 로 읽었을 때의 값 — 파생이면 그 값, 아니면 상태 그대로 */
46
+ export type ReadOf<S> = S extends Derived<infer T> ? T : S;
47
+ /** creator 의 셋째 인자 — 다른 store 의 부르는 순간의 값을 꺼낸다. 인자 없이 부르면 자기 자신. 계산 공간(select · createDerived) 안에서 읽으면 그 store 를 따라간다 */
48
+ export interface Ctx<Self = unknown> {
49
+ /** 인자 없이 부르면 자기 상태를 준다. 짓는 동안에는 쓸 수 없고, 짓기 기록에도 적지 않는다 */
50
+ (): Self;
51
+ <T>(store: Store<T>): ReadOf<T>;
52
+ <T, N extends Names<T>, O extends PickOptions<T, N>>(store: Store<T>, options: O): Picked<T, O>;
53
+ }
54
+ /** store 를 짓는 함수 — 핸들을 받는 API 가 모두 이 꼴을 받는다 */
55
+ type CreatorOf<S> = (set: SetState<S>, get: GetState<S>, ctx: Ctx<S>) => S;
56
+ type PickFromOptions = {
57
+ pick?: readonly string[];
58
+ omit?: readonly string[];
59
+ };
60
+ /** 고른 칸만 담은 새 객체. 함수 칸은 원래 상태 객체를 this 로 묶는다 — 메서드 꼴 정의가 this 를 써도 된다 */
61
+ export declare function pickFrom(state: object, options?: PickFromOptions): object;
62
+ /**
63
+ * store 를 등록하고 그것을 가리키는 핸들을 돌려준다. 짓는 것은 처음 꺼낼 때다.
64
+ * 부를 때마다 새 store 다 — 모듈 최상단에서만 부른다. set·get 의 타입은 creator 의 반환 타입에서 온다.
65
+ * 인자를 받는 creator 는 타입 인자를 적는다 — 빠뜨리면 상태가 never 로 굳어 컴파일 오류가 난다
66
+ */
67
+ export declare function createStore<S extends object = never>(creator: CreatorOf<S>): Store<S>;
68
+ export declare namespace createStore {
69
+ /**
70
+ * `ctx` 만 쓰는 정의 — set · get 을 받지 않으므로 상태 타입이 돌려주는 값에서 추론된다.
71
+ * 동작은 `createStore((_set, _get, ctx) => creator(ctx))` 와 같다. `ctx()` 는 자기 타입을 모르므로 `unknown` 이다 —
72
+ * 자기 자신은 자기 핸들로 읽는다. 모듈 최상단에서만 부른다
73
+ */
74
+ function ofContext<S extends object>(creator: (ctx: Ctx) => S): Store<S>;
75
+ }
76
+ /** 처음 등록한 정의 대신 이것으로 짓는다. 그 store 에 기대던 store 도 다시 짓는다. 시험의 가짜는 일부 칸만 돌려줘도 된다 */
77
+ export declare function overrideStore<S>(store: Store<S>, creator: (set: SetState<S>, get: GetState<S>, ctx: Ctx<S>) => object): void;
78
+ /** 핸들이 가리키는 store — 핸들이 아니면 `store 핸들이 아니다` 로 실패한다. 다시 지어도 같은 객체다 */
79
+ export declare function getStore<S>(store: Store<S>): StoreApi<S>;
80
+ /** 덮어쓴 정의를 모두 지우고, 전부 무른 뒤 지어져 있던 것을 다시 지어 알린다. 구독자는 남는다 — 시험 사이에 부른다 */
81
+ export declare function resetStores(): void;
82
+ /** 지어진 모든 store 의 [DISPOSE] 를 부르고 지어지지 않은 상태로 되돌린다. 다시 짓지 않는다(다음에 꺼낼 때 짓는다) — 구독자는 남는다 */
83
+ export declare function disposeStores(): void;
84
+ /** 등록한 store 전부, 등록한 차례대로 — 앱 전체에 거는 일(다시 이어졌을 때 모든 자원을 낡게 하기 같은)에 쓴다 */
85
+ export declare function registeredStores(): Store<unknown>[];
86
+ /**
87
+ * @internal — 지금 짓고 있는 store. adopt 로 맡긴 함수는 그 store 를 dispose 할 때 [DISPOSE] 뒤에 돈다(query.ts 의 event 가 쓴다).
88
+ * store 를 가리는 것은 handle 이다 — label 은 한 도우미 함수 안에서 지은 store 끼리 겹치므로 문구와 기록에만 쓴다
89
+ */
90
+ export declare function currentBuild(): {
91
+ label: string;
92
+ handle: Store<unknown>;
93
+ adopt(off: () => void): void;
94
+ } | undefined;
package/dist/index.js ADDED
@@ -0,0 +1,220 @@
1
+ import { labelFromStack } from "./label.js";
2
+ import { resetScopes } from "./mutation.js";
3
+ import { DERIVED, noteRead } from "./track.js";
4
+ export { DERIVED };
5
+ /** 상태에 이 표식으로 함수를 두면 useStore 가 꺼내기를 그 함수에 맡긴다 — 그 함수는 훅이다 */
6
+ export const USE = Symbol.for("supa-store.use");
7
+ /** 상태 객체에 `[DISPOSE]: () => void` 가 있으면 그 store 를 다시 짓기 직전과 disposeStores 에서 부른다 */
8
+ export const DISPOSE = Symbol.for("supa-store.dispose");
9
+ /** 등록한 차례대로 */
10
+ const entries = [];
11
+ /** 핸들에서 entry 로 가는 길 — 라이브러리 안에만 둔다 */
12
+ const entryOfHandle = new WeakMap();
13
+ /** 지금 짓고 있는 store 의 사슬 — 같은 store 가 다시 나오면 순환이다 */
14
+ const building = [];
15
+ /** 고른 칸만 담은 새 객체. 함수 칸은 원래 상태 객체를 this 로 묶는다 — 메서드 꼴 정의가 this 를 써도 된다 */
16
+ export function pickFrom(state, options) {
17
+ if (!options?.pick && !options?.omit)
18
+ return state;
19
+ const source = state;
20
+ const omit = options.omit ?? [];
21
+ const names = options.pick ?? Object.keys(source).filter((name) => !omit.includes(name));
22
+ const out = {};
23
+ for (const name of names) {
24
+ const value = source[name];
25
+ out[name] = typeof value === "function" ? value.bind(state) : value;
26
+ }
27
+ return out;
28
+ }
29
+ function entryOf(store) {
30
+ const entry = typeof store === "object" && store !== null ? entryOfHandle.get(store) : undefined;
31
+ if (!entry)
32
+ throw new Error("store 핸들이 아니다");
33
+ return entry;
34
+ }
35
+ /** 맡은 정리 함수를 모두 부르고 비운다. 하나가 던져도 나머지를 부르고 밖으로 새지 않는다 */
36
+ function runOffs(entry) {
37
+ for (const off of entry.offs.splice(0)) {
38
+ try {
39
+ off();
40
+ }
41
+ catch (error) {
42
+ console.error(`맡은 정리 함수가 던졌다: ${entry.label}`, error);
43
+ }
44
+ }
45
+ }
46
+ function ensure(entry) {
47
+ if (!entry.built)
48
+ entry.build();
49
+ return entry;
50
+ }
51
+ function makeEntry(label, definition) {
52
+ let state;
53
+ let initial;
54
+ const listeners = new Set();
55
+ const get = () => state;
56
+ const setState = (partial) => {
57
+ ensure(entry);
58
+ const next = typeof partial === "function" ? partial(state) : partial;
59
+ if (Object.is(next, state))
60
+ return;
61
+ state = Object.assign({}, state, next);
62
+ listeners.forEach((l) => l());
63
+ };
64
+ const ctx = ((...args) => {
65
+ const [other, options] = args;
66
+ if (other === undefined) {
67
+ if (building[building.length - 1] === entry)
68
+ throw new Error(`짓는 동안에는 자기 자신을 꺼낼 수 없다: ${label}`);
69
+ return entry.api.getState();
70
+ }
71
+ const target = entryOf(other);
72
+ // 짓는 동안 꺼낸 store 만 기록한다. 동작 안에서 부를 때 꺼낸 것은 기댐이 아니다
73
+ if (building[building.length - 1] === entry)
74
+ entry.deps.add(target);
75
+ ensure(target);
76
+ // 계산 공간(track) 안이면 읽었다고 적는다 — 어느 store 의 ctx 로 읽었는지는 가리지 않는다
77
+ noteRead(target.channel);
78
+ const state = target.api.getState();
79
+ // 파생은 상태가 아니라 값을 준다 — 그 값의 채널도 적어 파생이 파생을 따라간다
80
+ if (state && typeof state === "object" && DERIVED in state) {
81
+ noteRead(state[DERIVED]);
82
+ return state.get();
83
+ }
84
+ return pickFrom(state, options);
85
+ });
86
+ const entry = {
87
+ label,
88
+ handle: Object.freeze({}),
89
+ definition,
90
+ built: false,
91
+ deps: new Set(),
92
+ offs: [],
93
+ listeners,
94
+ api: {
95
+ getState: () => (ensure(entry), state),
96
+ getInitialState: () => (ensure(entry), initial),
97
+ setState,
98
+ subscribe(listener) {
99
+ listeners.add(listener);
100
+ return () => void listeners.delete(listener);
101
+ },
102
+ },
103
+ channel: {
104
+ subscribe(listener) {
105
+ listeners.add(listener);
106
+ return () => void listeners.delete(listener);
107
+ },
108
+ snapshot: () => (ensure(entry), state),
109
+ },
110
+ dispose() {
111
+ if (!entry.built)
112
+ return;
113
+ try {
114
+ state?.[DISPOSE]?.();
115
+ }
116
+ catch (error) {
117
+ console.error(`[DISPOSE] 가 던졌다: ${label}`, error);
118
+ }
119
+ runOffs(entry);
120
+ },
121
+ build() {
122
+ if (building.includes(entry))
123
+ throw new Error(`순환한다: ${[...building, entry].map((e) => e.label).join(" → ")}`);
124
+ building.push(entry);
125
+ try {
126
+ entry.deps.clear();
127
+ state = initial = (entry.override ?? entry.definition)(setState, get, ctx);
128
+ entry.built = true;
129
+ }
130
+ catch (error) {
131
+ runOffs(entry);
132
+ throw error;
133
+ }
134
+ finally {
135
+ building.pop();
136
+ }
137
+ },
138
+ };
139
+ return entry;
140
+ }
141
+ /**
142
+ * 주어진 store 와, 지을 때 그것을 꺼낸 store 를 (거슬러 올라가며) 모두 무른다.
143
+ * 무르기 전에 지어져 있던 것은 곧 다시 짓고(듣기가 새 store 에 다시 걸린다), 구독자가 있으면 알린다
144
+ */
145
+ function rebuild(targets) {
146
+ const stale = new Set();
147
+ const mark = (entry) => {
148
+ if (stale.has(entry))
149
+ return;
150
+ stale.add(entry);
151
+ entries.forEach((other) => other.deps.has(entry) && mark(other));
152
+ };
153
+ for (const entry of targets)
154
+ mark(entry);
155
+ const again = [...stale].filter((entry) => entry.built);
156
+ again.forEach((entry) => entry.dispose());
157
+ stale.forEach((entry) => (entry.built = false));
158
+ again.forEach(ensure);
159
+ again.forEach((entry) => entry.listeners.forEach((l) => l()));
160
+ }
161
+ /**
162
+ * store 를 등록하고 그것을 가리키는 핸들을 돌려준다. 짓는 것은 처음 꺼낼 때다.
163
+ * 부를 때마다 새 store 다 — 모듈 최상단에서만 부른다. set·get 의 타입은 creator 의 반환 타입에서 온다.
164
+ * 인자를 받는 creator 는 타입 인자를 적는다 — 빠뜨리면 상태가 never 로 굳어 컴파일 오류가 난다
165
+ */
166
+ export function createStore(creator) {
167
+ // stack 은 이 모듈 안에서 만든다 — labelFromStack 이 이 파일의 프레임을 건너뛰고 부른 자리를 읽는다
168
+ const label = (process.env.NODE_ENV === "production" ? null : labelFromStack(new Error().stack)) ?? `#${entries.length + 1}`;
169
+ const entry = makeEntry(label, creator);
170
+ entries.push(entry);
171
+ entryOfHandle.set(entry.handle, entry);
172
+ return entry.handle;
173
+ }
174
+ (function (createStore) {
175
+ /**
176
+ * `ctx` 만 쓰는 정의 — set · get 을 받지 않으므로 상태 타입이 돌려주는 값에서 추론된다.
177
+ * 동작은 `createStore((_set, _get, ctx) => creator(ctx))` 와 같다. `ctx()` 는 자기 타입을 모르므로 `unknown` 이다 —
178
+ * 자기 자신은 자기 핸들로 읽는다. 모듈 최상단에서만 부른다
179
+ */
180
+ function ofContext(creator) {
181
+ // 이 파일 안에서 createStore 를 부르므로 이름은 이 프레임까지 건너뛰고 ofContext 를 부른 자리를 읽는다
182
+ return createStore((_set, _get, ctx) => creator(ctx));
183
+ }
184
+ createStore.ofContext = ofContext;
185
+ })(createStore || (createStore = {}));
186
+ /** 처음 등록한 정의 대신 이것으로 짓는다. 그 store 에 기대던 store 도 다시 짓는다. 시험의 가짜는 일부 칸만 돌려줘도 된다 */
187
+ export function overrideStore(store, creator) {
188
+ const entry = entryOf(store);
189
+ entry.override = creator;
190
+ rebuild([entry]);
191
+ }
192
+ /** 핸들이 가리키는 store — 핸들이 아니면 `store 핸들이 아니다` 로 실패한다. 다시 지어도 같은 객체다 */
193
+ export function getStore(store) {
194
+ return entryOf(store).api;
195
+ }
196
+ /** 덮어쓴 정의를 모두 지우고, 전부 무른 뒤 지어져 있던 것을 다시 지어 알린다. 구독자는 남는다 — 시험 사이에 부른다 */
197
+ export function resetStores() {
198
+ entries.forEach((entry) => (entry.override = undefined));
199
+ rebuild(entries);
200
+ resetScopes();
201
+ }
202
+ /** 지어진 모든 store 의 [DISPOSE] 를 부르고 지어지지 않은 상태로 되돌린다. 다시 짓지 않는다(다음에 꺼낼 때 짓는다) — 구독자는 남는다 */
203
+ export function disposeStores() {
204
+ entries.forEach((entry) => {
205
+ entry.dispose();
206
+ entry.built = false;
207
+ });
208
+ }
209
+ /** 등록한 store 전부, 등록한 차례대로 — 앱 전체에 거는 일(다시 이어졌을 때 모든 자원을 낡게 하기 같은)에 쓴다 */
210
+ export function registeredStores() {
211
+ return entries.map((entry) => entry.handle);
212
+ }
213
+ /**
214
+ * @internal — 지금 짓고 있는 store. adopt 로 맡긴 함수는 그 store 를 dispose 할 때 [DISPOSE] 뒤에 돈다(query.ts 의 event 가 쓴다).
215
+ * store 를 가리는 것은 handle 이다 — label 은 한 도우미 함수 안에서 지은 store 끼리 겹치므로 문구와 기록에만 쓴다
216
+ */
217
+ export function currentBuild() {
218
+ const entry = building[building.length - 1];
219
+ return entry && { label: entry.label, handle: entry.handle, adopt: (off) => void entry.offs.push(off) };
220
+ }
@@ -0,0 +1,5 @@
1
+ /**
2
+ * `new Error().stack` 에서 첫 프레임(이 stack 을 만든 라이브러리 파일)과 다른 파일의
3
+ * 첫 프레임을 `<경로>:<줄>` 로 돌려준다. 가려내지 못하면 null.
4
+ */
5
+ export declare function labelFromStack(stack: string | undefined): string | null;
package/dist/label.js ADDED
@@ -0,0 +1,38 @@
1
+ // 부른 자리에서 store 의 이름을 읽는다. 오류 메시지에 store 를 가리키는 데만 쓴다.
2
+ /** 위치 문자열 `<경로>:<줄>:<열>` 을 다듬은 경로와 줄로 가른다. 꼴이 아니면 null. */
3
+ function parseLocation(loc) {
4
+ const m = /^(.*):(\d+):\d+$/.exec(loc.trim());
5
+ if (!m)
6
+ return null;
7
+ const path = m[1]
8
+ .replace(/\\/g, "/")
9
+ .replace(/\?.*$/, "")
10
+ .replace(/^https?:\/\/[^/]+\//, "")
11
+ .replace(/^webpack-internal:\/\/\//, "")
12
+ .replace(/^\([^)]*\)\//, "")
13
+ .replace(/^\.\//, "")
14
+ .replace(/^file:\/\/\/(?=[A-Za-z]:)/, "")
15
+ .replace(/^file:\/\//, "");
16
+ return { path, line: m[2] };
17
+ }
18
+ /** 한 줄에서 위치를 뽑는다. V8(`at fn (위치)` · `at 위치`)과 Firefox(`fn@위치`)를 읽는다. */
19
+ function parseFrame(text) {
20
+ const t = text.trim();
21
+ const v8 = /^at (?:.*? \()?(.*?)\)?$/.exec(t);
22
+ if (v8)
23
+ return parseLocation(v8[1]);
24
+ const at = t.indexOf("@");
25
+ return at < 0 ? null : parseLocation(t.slice(at + 1));
26
+ }
27
+ /**
28
+ * `new Error().stack` 에서 첫 프레임(이 stack 을 만든 라이브러리 파일)과 다른 파일의
29
+ * 첫 프레임을 `<경로>:<줄>` 로 돌려준다. 가려내지 못하면 null.
30
+ */
31
+ export function labelFromStack(stack) {
32
+ if (!stack)
33
+ return null;
34
+ const frames = stack.split("\n").map(parseFrame).filter((f) => f !== null);
35
+ const own = frames[0]?.path;
36
+ const caller = frames.find((f) => f.path !== own);
37
+ return caller ? `${caller.path}:${caller.line}` : null;
38
+ }
@@ -0,0 +1,46 @@
1
+ import { type Channel } from "./track.js";
2
+ type Fn = (...args: any[]) => any;
3
+ /** 바꾸기 하나의 상태 — 바뀔 때마다 새 객체다 */
4
+ export interface MutationSnapshot<F extends Fn> {
5
+ /** 보냈지만 아직 끝나지 않은 호출들의 인자 — 보낸 차례대로 선다 */
6
+ readonly inflight: readonly Parameters<F>[];
7
+ /** 겹에 얹을 호출들의 인자 — inflight 에서 밀려난 호출을 뺀 것. 보낸 차례대로 선다 */
8
+ readonly optimistic: readonly Parameters<F>[];
9
+ readonly pending: boolean;
10
+ /** 마지막으로 끝난, 밀려나지 않은 호출이 실패했으면 그 문구 */
11
+ readonly error: string | null;
12
+ /** 마지막으로 성공한, 밀려나지 않은 호출의 결과 */
13
+ readonly data: Awaited<ReturnType<F>> | undefined;
14
+ }
15
+ /** 부를 수 있는 바꾸기 — 언제나 Promise 를 돌려준다(동기 함수여도). 상태 칸은 읽기 전용 속성 */
16
+ export type MutationFn<F extends Fn> = ((...args: Parameters<F>) => Promise<Awaited<ReturnType<F>>>) & MutationSnapshot<F> & {
17
+ reset(): void;
18
+ };
19
+ export interface MutationHooks<F extends Fn> {
20
+ onSuccess?: (result: Awaited<ReturnType<F>>, ...args: Parameters<F>) => void;
21
+ onError?: (error: unknown, ...args: Parameters<F>) => void;
22
+ onSettled?: (result: Awaited<ReturnType<F>> | undefined, error: unknown, ...args: Parameters<F>) => void;
23
+ /** 이 바꾸기의 inflight 가 빌 때마다 한 번 — 돌려준 Promise 가 끝날 때까지 성공한 호출을 optimistic 에 남긴다 */
24
+ onAllSettled?: () => unknown;
25
+ /** 같은 id 의 바꾸기를 한 줄에 세운다 */
26
+ scope?: {
27
+ id: string;
28
+ };
29
+ }
30
+ /** 구독 단위 — 화면 훅과 계산 공간(`track`)이 쓴다 */
31
+ export interface MutationChannel extends Channel {
32
+ snapshot(): MutationSnapshot<Fn>;
33
+ }
34
+ export declare const message: (e: unknown) => string;
35
+ /** 시험 사이에 줄이 남지 않도록 비운다 */
36
+ export declare function resetScopes(): void;
37
+ /**
38
+ * 바꾸기 함수를 감싸 상태 칸을 쥔다. 호출마다 안쪽 번호를 매긴다 — 같은 인자로 두 번 불러도 끝난 쪽만 inflight 에서 뺀다.
39
+ * 나중에 보낸 호출이 성공하면 앞 호출은 모두 밀려난다: 그 순간 optimistic 에서 빠지고, 응답은 칸과 콜백을 건드리지 않는다.
40
+ * 나중 호출의 실패는 아무것도 밀어내지 않는다. reset 앞에 보낸 호출은 칸에만 적지 않는다
41
+ */
42
+ export declare function createMutation<F extends Fn>(fn: F, hooks?: MutationHooks<F>): {
43
+ call: MutationFn<F>;
44
+ channel: MutationChannel;
45
+ };
46
+ export {};
@@ -0,0 +1,131 @@
1
+ // 바꾸기 하나의 상태 — 자원이 쥐고, 어디서 부르든 같은 칸을 거친다. React 를 가져오지 않는다
2
+ import { noteRead } from "./track.js";
3
+ export const message = (e) => (e instanceof Error ? e.message : String(e));
4
+ /** scope.id → 그 줄 마지막 호출이 끝나면 풀리는 약속 — 던지지 않는다 */
5
+ const scopes = new Map();
6
+ /** 시험 사이에 줄이 남지 않도록 비운다 */
7
+ export function resetScopes() {
8
+ scopes.clear();
9
+ }
10
+ const FIELDS = ["inflight", "optimistic", "pending", "error", "data"];
11
+ /** 콜백이 던져도 호출의 결과와 inflight 를 붙잡지 않는다 — 콘솔에 남기고 삼킨다 */
12
+ function safely(cb, ...args) {
13
+ try {
14
+ cb?.(...args);
15
+ }
16
+ catch (e) {
17
+ console.error(e);
18
+ }
19
+ }
20
+ /**
21
+ * 바꾸기 함수를 감싸 상태 칸을 쥔다. 호출마다 안쪽 번호를 매긴다 — 같은 인자로 두 번 불러도 끝난 쪽만 inflight 에서 뺀다.
22
+ * 나중에 보낸 호출이 성공하면 앞 호출은 모두 밀려난다: 그 순간 optimistic 에서 빠지고, 응답은 칸과 콜백을 건드리지 않는다.
23
+ * 나중 호출의 실패는 아무것도 밀어내지 않는다. reset 앞에 보낸 호출은 칸에만 적지 않는다
24
+ */
25
+ export function createMutation(fn, hooks = {}) {
26
+ const listeners = new Set();
27
+ let state = { inflight: [], optimistic: [], pending: false, error: null, data: undefined };
28
+ /** 응답을 기다리는 호출 — inflight */
29
+ let calls = [];
30
+ /** 겹에 얹을 호출 — optimistic */
31
+ let shown = [];
32
+ let sent = 0;
33
+ /** 성공한 가장 큰 번호 — 이보다 작은 호출은 밀려나 칸도 콜백도 건드리지 않는다 */
34
+ let won = 0;
35
+ /** 시작한 확인의 수 — 가장 나중 확인이 끝날 때만 겹을 비운다 */
36
+ let confirms = 0;
37
+ /** reset 할 때 보낸 가장 큰 번호 — 이보다 작거나 같은 호출은 칸에 적지 않지만 콜백은 부른다 */
38
+ let floor = 0;
39
+ const write = (patch) => {
40
+ state = { ...state, ...patch };
41
+ listeners.forEach((l) => l());
42
+ };
43
+ const publish = (patch = {}) => write({ ...patch, inflight: calls.map((c) => c.args), optimistic: shown.map((c) => c.args), pending: calls.length > 0 });
44
+ const channel = {
45
+ subscribe(listener) {
46
+ listeners.add(listener);
47
+ return () => void listeners.delete(listener);
48
+ },
49
+ snapshot: () => state,
50
+ };
51
+ // 확인이 던지거나 거부되어도 끝난 것으로 본다 — 앞 확인이 뒤 확인의 겹을 비우지 않게 번호로 가린다
52
+ const confirm = async () => {
53
+ const mine = ++confirms;
54
+ try {
55
+ await hooks.onAllSettled();
56
+ }
57
+ catch (e) {
58
+ console.error(e);
59
+ }
60
+ if (mine === confirms && calls.length === 0) {
61
+ shown = [];
62
+ publish();
63
+ }
64
+ };
65
+ const call = async (...args) => {
66
+ const n = ++sent;
67
+ const mine = { n, args };
68
+ calls = [...calls, mine];
69
+ shown = [...shown, mine];
70
+ // 다시 부르면 앞 실패의 문구를 지운다 — 0.2 의 화면별 바꾸기와 같다
71
+ publish({ error: null });
72
+ // 같은 scope 의 앞 호출이 끝나기를 기다린다 — 앞이 실패해도 줄은 풀린다
73
+ const id = hooks.scope?.id;
74
+ const prev = id === undefined ? undefined : scopes.get(id);
75
+ let release = () => { };
76
+ let ok = false;
77
+ if (id !== undefined) {
78
+ const mine = new Promise((r) => (release = () => (scopes.get(id) === mine && scopes.delete(id), r())));
79
+ scopes.set(id, mine);
80
+ }
81
+ try {
82
+ if (prev)
83
+ await prev;
84
+ const result = await fn(...args);
85
+ ok = true;
86
+ if (n > won) {
87
+ won = n;
88
+ shown = shown.filter((c) => c.n >= n);
89
+ publish(n > floor ? { data: result, error: null } : {});
90
+ safely(hooks.onSuccess, result, ...args);
91
+ safely(hooks.onSettled, result, null, ...args);
92
+ }
93
+ return result;
94
+ }
95
+ catch (e) {
96
+ if (n > won) {
97
+ if (n > floor)
98
+ write({ error: message(e) });
99
+ safely(hooks.onError, e, ...args);
100
+ safely(hooks.onSettled, undefined, e, ...args);
101
+ }
102
+ throw e;
103
+ }
104
+ finally {
105
+ // 칸과 콜백이 먼저 — 그 뒤에 빠져야 캐시가 서버 값이 된 다음 겹이 빠진다
106
+ calls = calls.filter((c) => c !== mine);
107
+ // 확인을 켰으면 성공한 호출은 확인이 끝날 때까지 겹에 남는다 — 실패한 호출은 바로 빠지고, 밀려났으면 위에서 이미 빠졌다
108
+ if (!hooks.onAllSettled || !ok)
109
+ shown = shown.filter((c) => c !== mine);
110
+ publish();
111
+ release();
112
+ // 호출의 Promise 사슬 밖에서 돈다 — mutateAsync 는 확인을 기다리지 않는다
113
+ if (hooks.onAllSettled && calls.length === 0)
114
+ void confirm();
115
+ }
116
+ };
117
+ for (const field of FIELDS) {
118
+ Object.defineProperty(call, field, {
119
+ get() {
120
+ noteRead(channel);
121
+ return state[field];
122
+ },
123
+ });
124
+ }
125
+ // 앞서 떠난 호출이 칸에 적지 못하게 한다 — 그 콜백은 돈다. inflight 는 그 호출이 끝날 때 빠진다
126
+ const reset = () => {
127
+ floor = sent;
128
+ write({ error: null, data: undefined });
129
+ };
130
+ return { call: Object.assign(call, { reset }), channel };
131
+ }