squiffy-runtime 6.0.1 → 7.0.0-beta.11
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/dist/assets.d.ts +3 -0
- package/dist/assets.test.d.ts +1 -0
- package/dist/classes.test.d.ts +1 -0
- package/dist/confirmDialog.d.ts +8 -0
- package/dist/events.d.ts +16 -0
- package/dist/every.d.ts +12 -0
- package/dist/every.test.d.ts +1 -0
- package/dist/helpers.test.d.ts +1 -0
- package/dist/numbers.d.ts +3 -0
- package/dist/panels.d.ts +14 -0
- package/dist/panels.test.d.ts +1 -0
- package/dist/paths.d.ts +15 -0
- package/dist/paths.test.d.ts +1 -0
- package/dist/persistent.test.d.ts +1 -0
- package/dist/playerSettings.d.ts +17 -0
- package/dist/pluginManager.d.ts +2 -1
- package/dist/preview-host.d.ts +33 -0
- package/dist/preview-host.js +125 -0
- package/dist/preview-host.js.map +7 -0
- package/dist/preview-host.test.d.ts +1 -0
- package/dist/preview-html.d.ts +2 -0
- package/dist/preview-html.js +2 -0
- package/dist/preview-protocol.d.ts +69 -0
- package/dist/preview.d.ts +15 -0
- package/dist/preview.main.d.ts +1 -0
- package/dist/preview.test.d.ts +1 -0
- package/dist/saveSlots.d.ts +16 -0
- package/dist/saves.test.d.ts +1 -0
- package/dist/savesDialog.d.ts +43 -0
- package/dist/savesDialog.test.d.ts +1 -0
- package/dist/scripts.test.d.ts +1 -0
- package/dist/settings.test.d.ts +1 -0
- package/dist/settingsDialog.d.ts +17 -0
- package/dist/skill.test.d.ts +1 -0
- package/dist/sound.d.ts +35 -0
- package/dist/sound.test.d.ts +1 -0
- package/dist/squiffy.page.css +155 -0
- package/dist/squiffy.preview.html +1631 -0
- package/dist/squiffy.runtime.css +1123 -20
- package/dist/squiffy.runtime.d.ts +13 -1
- package/dist/squiffy.runtime.global.js +146 -76
- package/dist/squiffy.runtime.global.js.map +1 -1
- package/dist/squiffy.runtime.js +7105 -4681
- package/dist/squiffy.runtime.js.map +1 -1
- package/dist/state.d.ts +17 -0
- package/dist/storyLists.d.ts +4 -0
- package/dist/storyLists.test.d.ts +1 -0
- package/dist/style.test.d.ts +1 -0
- package/dist/textProcessor.d.ts +27 -0
- package/dist/transitions.test.d.ts +1 -0
- package/dist/types.d.ts +137 -1
- package/dist/types.plugins.d.ts +2 -0
- package/dist/uiLinks.test.d.ts +1 -0
- package/dist/utils.d.ts +2 -1
- package/dist/utils.test.d.ts +1 -0
- package/package.json +25 -11
- package/src/__snapshots__/squiffy.runtime.test.ts.snap +22 -22
- package/src/animation.test.ts +44 -0
- package/src/animation.ts +9 -5
- package/src/assets.test.ts +225 -0
- package/src/assets.ts +92 -0
- package/src/classes.test.ts +201 -0
- package/src/confirmDialog.ts +66 -0
- package/src/events.ts +20 -0
- package/src/every.test.ts +25 -0
- package/src/every.ts +94 -0
- package/src/helpers.test.ts +34 -0
- package/src/numbers.ts +21 -0
- package/src/panels.test.ts +225 -0
- package/src/panels.ts +187 -0
- package/src/paths.test.ts +66 -0
- package/src/paths.ts +155 -0
- package/src/persistent.test.ts +155 -0
- package/src/playerSettings.ts +128 -0
- package/src/pluginManager.ts +6 -1
- package/src/plugins/animate.ts +34 -9
- package/src/plugins/live.ts +18 -5
- package/src/plugins/plugins.test.ts +93 -6
- package/src/plugins/replaceLabel.ts +7 -3
- package/src/preview-host.test.ts +171 -0
- package/src/preview-host.ts +190 -0
- package/src/preview-protocol.ts +79 -0
- package/src/preview.main.ts +34 -0
- package/src/preview.test.ts +367 -0
- package/src/preview.ts +331 -0
- package/src/saveSlots.ts +159 -0
- package/src/saves.test.ts +199 -0
- package/src/savesDialog.test.ts +290 -0
- package/src/savesDialog.ts +499 -0
- package/src/scripts.test.ts +130 -0
- package/src/settings.test.ts +233 -0
- package/src/settingsDialog.ts +160 -0
- package/src/skill.test.ts +67 -0
- package/src/sound.test.ts +273 -0
- package/src/sound.ts +207 -0
- package/src/squiffy.page.css +155 -0
- package/src/squiffy.runtime.css +1123 -20
- package/src/squiffy.runtime.test.ts +2806 -44
- package/src/squiffy.runtime.ts +1130 -64
- package/src/state.ts +172 -11
- package/src/storyLists.test.ts +134 -0
- package/src/storyLists.ts +57 -0
- package/src/style.test.ts +89 -0
- package/src/textProcessor.ts +739 -58
- package/src/transitions.test.ts +343 -0
- package/src/types.plugins.ts +7 -0
- package/src/types.ts +226 -2
- package/src/uiLinks.test.ts +156 -0
- package/src/updater.ts +26 -8
- package/src/utils.test.ts +60 -0
- package/src/utils.ts +46 -14
- package/vite.config.ts +3 -4
- package/vite.preview.config.ts +83 -0
- package/dist/infixExpressions.d.ts +0 -2
- package/src/infixExpressions.test.ts +0 -187
- package/src/infixExpressions.ts +0 -323
- /package/dist/{infixExpressions.test.d.ts → animation.test.d.ts} +0 -0
|
@@ -0,0 +1,343 @@
|
|
|
1
|
+
// @transition (#489): how a section or passage appears
|
|
2
|
+
import { expect, test, beforeEach, afterEach, vi } from "vitest";
|
|
3
|
+
import globalJsdom from "global-jsdom";
|
|
4
|
+
import { init } from "./squiffy.runtime.js";
|
|
5
|
+
import { compile as squiffyCompile } from "squiffy-compiler";
|
|
6
|
+
|
|
7
|
+
let cleanup: () => void;
|
|
8
|
+
|
|
9
|
+
beforeEach(() => {
|
|
10
|
+
cleanup = globalJsdom("<!DOCTYPE html><html><body><div id=\"squiffy\"></div></body></html>");
|
|
11
|
+
vi.useFakeTimers();
|
|
12
|
+
});
|
|
13
|
+
|
|
14
|
+
afterEach(() => {
|
|
15
|
+
vi.useRealTimers();
|
|
16
|
+
localStorage.clear();
|
|
17
|
+
cleanup();
|
|
18
|
+
});
|
|
19
|
+
|
|
20
|
+
const start = async (script: string, options: { persist?: boolean } = {}) => {
|
|
21
|
+
const result = await squiffyCompile({ script });
|
|
22
|
+
if (!result.success) throw new Error("Compile failed");
|
|
23
|
+
const story = {
|
|
24
|
+
...result.output.story,
|
|
25
|
+
js: result.output.js.map(lines => new Function("squiffy", "get", "set", lines.join("\n"))) as any,
|
|
26
|
+
};
|
|
27
|
+
const element = document.getElementById("squiffy")!;
|
|
28
|
+
const api = await init({ element, story, persist: options.persist ?? false, storyId: "test", scroll: "none" });
|
|
29
|
+
await api.begin();
|
|
30
|
+
return { api, element };
|
|
31
|
+
};
|
|
32
|
+
|
|
33
|
+
const click = async (element: HTMLElement, text: string) => {
|
|
34
|
+
const link = [...element.querySelectorAll<HTMLElement>("a.squiffy-link")]
|
|
35
|
+
.find(l => l.textContent == text && !l.classList.contains("disabled"));
|
|
36
|
+
if (!link) throw new Error(`No link "${text}"`);
|
|
37
|
+
link.click();
|
|
38
|
+
await vi.runAllTimersAsync();
|
|
39
|
+
};
|
|
40
|
+
|
|
41
|
+
const sectionElement = (element: HTMLElement, name: string) =>
|
|
42
|
+
element.querySelector<HTMLElement>(`.squiffy-output-section[data-section="${name}"]`)!;
|
|
43
|
+
|
|
44
|
+
const passageElement = (element: HTMLElement, name: string) =>
|
|
45
|
+
element.querySelector<HTMLElement>(`.squiffy-output-passage[data-passage="${name}"]`)!;
|
|
46
|
+
|
|
47
|
+
// What a transition puts on an element while it plays
|
|
48
|
+
const transition = (el: HTMLElement) => el.classList.contains("squiffy-transition")
|
|
49
|
+
? { name: el.getAttribute("data-transition"), time: el.style.getPropertyValue("--squiffy-transition-time") }
|
|
50
|
+
: null;
|
|
51
|
+
|
|
52
|
+
const story = `
|
|
53
|
+
[[forest]]:
|
|
54
|
+
@transition fade
|
|
55
|
+
The forest. [[Go to the cave]](cave), [look up], [listen]
|
|
56
|
+
|
|
57
|
+
[look up]:
|
|
58
|
+
@transition zoom 300ms
|
|
59
|
+
The stars are out.
|
|
60
|
+
|
|
61
|
+
[listen]:
|
|
62
|
+
Owls.
|
|
63
|
+
|
|
64
|
+
[[cave]]:
|
|
65
|
+
@transition slide-up 1.5s
|
|
66
|
+
@clear
|
|
67
|
+
The cave. [[Leave]](outside)
|
|
68
|
+
|
|
69
|
+
[[outside]]:
|
|
70
|
+
Outside.
|
|
71
|
+
`;
|
|
72
|
+
|
|
73
|
+
test("A section's transition plays as it appears, with its time", async () => {
|
|
74
|
+
const { element } = await start(story);
|
|
75
|
+
expect(transition(sectionElement(element, "forest"))).toEqual({ name: "fade", time: "" });
|
|
76
|
+
expect(sectionElement(element, "forest").classList).toContain("fade");
|
|
77
|
+
|
|
78
|
+
await click(element, "Go to the cave");
|
|
79
|
+
expect(transition(sectionElement(element, "cave"))).toEqual({ name: "slide-up", time: "1500ms" });
|
|
80
|
+
|
|
81
|
+
await click(element, "Leave");
|
|
82
|
+
expect(transition(sectionElement(element, "outside"))).toBeNull();
|
|
83
|
+
});
|
|
84
|
+
|
|
85
|
+
test("A passage has its own transition, or else its section's", async () => {
|
|
86
|
+
const { element } = await start(story);
|
|
87
|
+
await click(element, "look up");
|
|
88
|
+
expect(transition(passageElement(element, "look up"))).toEqual({ name: "zoom", time: "300ms" });
|
|
89
|
+
|
|
90
|
+
await click(element, "listen");
|
|
91
|
+
expect(transition(passageElement(element, "listen"))).toEqual({ name: "fade", time: "" });
|
|
92
|
+
});
|
|
93
|
+
|
|
94
|
+
test("The master section's transition is for every section, unless one has @transition none", async () => {
|
|
95
|
+
const { element } = await start(`
|
|
96
|
+
[[]]:
|
|
97
|
+
@transition blur 1s
|
|
98
|
+
|
|
99
|
+
[[a]]:
|
|
100
|
+
A. [[b]] [p]
|
|
101
|
+
|
|
102
|
+
[p]:
|
|
103
|
+
P.
|
|
104
|
+
|
|
105
|
+
[[b]]:
|
|
106
|
+
@transition none
|
|
107
|
+
B.
|
|
108
|
+
`);
|
|
109
|
+
expect(transition(sectionElement(element, "a"))).toEqual({ name: "blur", time: "1000ms" });
|
|
110
|
+
await click(element, "p");
|
|
111
|
+
expect(transition(passageElement(element, "p"))).toEqual({ name: "blur", time: "1000ms" });
|
|
112
|
+
await click(element, "b");
|
|
113
|
+
expect(transition(sectionElement(element, "b"))).toBeNull();
|
|
114
|
+
});
|
|
115
|
+
|
|
116
|
+
test("The transition's class comes off when it ends", async () => {
|
|
117
|
+
const { element } = await start(story);
|
|
118
|
+
const forest = sectionElement(element, "forest");
|
|
119
|
+
// An animation in the text doesn't end the section's transition
|
|
120
|
+
forest.querySelector("p, div")!.dispatchEvent(new window.Event("animationend", { bubbles: true }));
|
|
121
|
+
expect(transition(forest)).not.toBeNull();
|
|
122
|
+
|
|
123
|
+
forest.dispatchEvent(new window.Event("animationend", { bubbles: true }));
|
|
124
|
+
expect(transition(forest)).toBeNull();
|
|
125
|
+
expect(forest.classList).not.toContain("fade");
|
|
126
|
+
expect(forest.hasAttribute("style")).toBe(false);
|
|
127
|
+
});
|
|
128
|
+
|
|
129
|
+
test("Going back past @clear doesn't play the transition again", async () => {
|
|
130
|
+
const { api, element } = await start(story);
|
|
131
|
+
await click(element, "Go to the cave");
|
|
132
|
+
api.goBack();
|
|
133
|
+
await vi.runAllTimersAsync();
|
|
134
|
+
expect(transition(sectionElement(element, "forest"))).toBeNull();
|
|
135
|
+
});
|
|
136
|
+
|
|
137
|
+
test("A saved game doesn't play the transitions again when it's loaded", async () => {
|
|
138
|
+
const first = await start(story, { persist: true });
|
|
139
|
+
await click(first.element, "Go to the cave");
|
|
140
|
+
expect(transition(sectionElement(first.element, "cave"))).not.toBeNull();
|
|
141
|
+
first.api.dispose();
|
|
142
|
+
first.element.innerHTML = "";
|
|
143
|
+
|
|
144
|
+
const second = await start(story, { persist: true });
|
|
145
|
+
expect(sectionElement(second.element, "cave")).not.toBeNull();
|
|
146
|
+
expect(second.element.querySelector(".squiffy-transition")).toBeNull();
|
|
147
|
+
});
|
|
148
|
+
|
|
149
|
+
// @leave: how the old text goes when the screen is cleared
|
|
150
|
+
|
|
151
|
+
// So the leave transitions have an animation, which jsdom doesn't play: it's ended by hand
|
|
152
|
+
const animateLeaving = () => {
|
|
153
|
+
const style = document.createElement("style");
|
|
154
|
+
style.textContent = ".squiffy-leave { animation-name: leaving; animation-duration: 1s; }";
|
|
155
|
+
document.head.appendChild(style);
|
|
156
|
+
};
|
|
157
|
+
|
|
158
|
+
const clickWithoutWaiting = async (element: HTMLElement, text: string) => {
|
|
159
|
+
const link = [...element.querySelectorAll<HTMLElement>("a.squiffy-link")]
|
|
160
|
+
.find(l => l.textContent == text && !l.classList.contains("disabled"));
|
|
161
|
+
if (!link) throw new Error(`No link "${text}"`);
|
|
162
|
+
link.click();
|
|
163
|
+
await vi.advanceTimersByTimeAsync(0);
|
|
164
|
+
};
|
|
165
|
+
|
|
166
|
+
const leaving = (el: HTMLElement) => el.classList.contains("squiffy-leave")
|
|
167
|
+
? { name: el.getAttribute("data-transition"), time: el.style.getPropertyValue("--squiffy-transition-time") }
|
|
168
|
+
: null;
|
|
169
|
+
|
|
170
|
+
const leaveStory = `
|
|
171
|
+
[[forest]]:
|
|
172
|
+
The forest. [[Go to the cave]](cave), [look up]
|
|
173
|
+
|
|
174
|
+
[look up]:
|
|
175
|
+
The stars are out.
|
|
176
|
+
|
|
177
|
+
[[cave]]:
|
|
178
|
+
@clear
|
|
179
|
+
@leave blur 2s
|
|
180
|
+
The cave. [listen]
|
|
181
|
+
|
|
182
|
+
[listen]:
|
|
183
|
+
@clear
|
|
184
|
+
Water dripping. [[Leave]](outside)
|
|
185
|
+
|
|
186
|
+
[[outside]]:
|
|
187
|
+
@clear
|
|
188
|
+
@leave none
|
|
189
|
+
Outside.
|
|
190
|
+
`;
|
|
191
|
+
|
|
192
|
+
test("The old text plays the leave transition before the screen is cleared", async () => {
|
|
193
|
+
animateLeaving();
|
|
194
|
+
const { api, element } = await start(leaveStory);
|
|
195
|
+
await click(element, "look up");
|
|
196
|
+
await clickWithoutWaiting(element, "Go to the cave");
|
|
197
|
+
|
|
198
|
+
// Everything on the screen is leaving, and the cave isn't there yet
|
|
199
|
+
const forest = sectionElement(element, "forest");
|
|
200
|
+
expect(leaving(forest)).toEqual({ name: "blur", time: "2000ms" });
|
|
201
|
+
expect(forest.classList).toContain("squiffy-transition");
|
|
202
|
+
expect(sectionElement(element, "cave")).toBeNull();
|
|
203
|
+
// Back waits for it
|
|
204
|
+
api.goBack();
|
|
205
|
+
await vi.advanceTimersByTimeAsync(0);
|
|
206
|
+
expect(leaving(forest)).not.toBeNull();
|
|
207
|
+
expect(passageElement(element, "look up")).not.toBeNull();
|
|
208
|
+
|
|
209
|
+
forest.dispatchEvent(new window.Event("animationend", { bubbles: true }));
|
|
210
|
+
await vi.runAllTimersAsync();
|
|
211
|
+
expect(sectionElement(element, "cave")).not.toBeNull();
|
|
212
|
+
// The old text is put away as it was, for going back
|
|
213
|
+
const putAway = element.querySelector<HTMLElement>(".squiffy-clear-stack .squiffy-output-section")!;
|
|
214
|
+
expect(putAway.getAttribute("data-section")).toBe("forest");
|
|
215
|
+
expect(putAway.classList).not.toContain("squiffy-leave");
|
|
216
|
+
expect(putAway.hasAttribute("style")).toBe(false);
|
|
217
|
+
});
|
|
218
|
+
|
|
219
|
+
test("A passage that clears the screen uses its section's leave transition, and @leave none plays none", async () => {
|
|
220
|
+
animateLeaving();
|
|
221
|
+
const { element } = await start(leaveStory);
|
|
222
|
+
await click(element, "Go to the cave");
|
|
223
|
+
|
|
224
|
+
await clickWithoutWaiting(element, "listen");
|
|
225
|
+
expect(leaving(sectionElement(element, "cave"))).toEqual({ name: "blur", time: "2000ms" });
|
|
226
|
+
await vi.runAllTimersAsync();
|
|
227
|
+
expect(passageElement(element, "listen")).not.toBeNull();
|
|
228
|
+
|
|
229
|
+
await clickWithoutWaiting(element, "Leave");
|
|
230
|
+
expect(sectionElement(element, "outside")).not.toBeNull();
|
|
231
|
+
});
|
|
232
|
+
|
|
233
|
+
test("The story goes on if the leave transition never ends", async () => {
|
|
234
|
+
animateLeaving();
|
|
235
|
+
const { element } = await start(leaveStory);
|
|
236
|
+
await clickWithoutWaiting(element, "Go to the cave");
|
|
237
|
+
await vi.advanceTimersByTimeAsync(1500);
|
|
238
|
+
expect(sectionElement(element, "cave")).toBeNull();
|
|
239
|
+
// Its 1s animation, and a second more
|
|
240
|
+
await vi.advanceTimersByTimeAsync(600);
|
|
241
|
+
expect(sectionElement(element, "cave")).not.toBeNull();
|
|
242
|
+
});
|
|
243
|
+
|
|
244
|
+
test("Without an animation for it, the leave transition doesn't hold the story up", async () => {
|
|
245
|
+
const { element } = await start(leaveStory);
|
|
246
|
+
await clickWithoutWaiting(element, "Go to the cave");
|
|
247
|
+
expect(sectionElement(element, "cave")).not.toBeNull();
|
|
248
|
+
});
|
|
249
|
+
|
|
250
|
+
test("Going back brings the old text back as it was", async () => {
|
|
251
|
+
animateLeaving();
|
|
252
|
+
const { api, element } = await start(leaveStory);
|
|
253
|
+
await click(element, "Go to the cave");
|
|
254
|
+
api.goBack();
|
|
255
|
+
await vi.runAllTimersAsync();
|
|
256
|
+
const forest = sectionElement(element, "forest");
|
|
257
|
+
expect(leaving(forest)).toBeNull();
|
|
258
|
+
expect(transition(forest)).toBeNull();
|
|
259
|
+
expect(sectionElement(element, "cave")).toBeNull();
|
|
260
|
+
});
|
|
261
|
+
|
|
262
|
+
test("The master section's leave transition is for every section that clears the screen", async () => {
|
|
263
|
+
animateLeaving();
|
|
264
|
+
const { element } = await start(`
|
|
265
|
+
[[]]:
|
|
266
|
+
@leave fade
|
|
267
|
+
|
|
268
|
+
[[a]]:
|
|
269
|
+
A. [[b]]
|
|
270
|
+
|
|
271
|
+
[[b]]:
|
|
272
|
+
@clear
|
|
273
|
+
B.
|
|
274
|
+
`);
|
|
275
|
+
await clickWithoutWaiting(element, "b");
|
|
276
|
+
expect(leaving(sectionElement(element, "a"))).toEqual({ name: "fade", time: "" });
|
|
277
|
+
});
|
|
278
|
+
|
|
279
|
+
test("{{clear}} plays the leave transition, then the new text's own transition", async () => {
|
|
280
|
+
// https://github.com/textadventures/squiffy/issues/524
|
|
281
|
+
animateLeaving();
|
|
282
|
+
const { element } = await start(`
|
|
283
|
+
[[a]]:
|
|
284
|
+
A. [[b]], [[c]]
|
|
285
|
+
|
|
286
|
+
[[b]]:
|
|
287
|
+
@leave blur 2s
|
|
288
|
+
@transition fade
|
|
289
|
+
{{clear}}B. [look]
|
|
290
|
+
|
|
291
|
+
[look]:
|
|
292
|
+
@transition zoom
|
|
293
|
+
@leave slide-up
|
|
294
|
+
{{clear}}Looking.
|
|
295
|
+
|
|
296
|
+
[[c]]:
|
|
297
|
+
C.
|
|
298
|
+
`);
|
|
299
|
+
await clickWithoutWaiting(element, "b");
|
|
300
|
+
// The old text is leaving, and the new text isn't there yet
|
|
301
|
+
expect(leaving(sectionElement(element, "a"))).toEqual({ name: "blur", time: "2000ms" });
|
|
302
|
+
expect(sectionElement(element, "b").textContent).toBe("");
|
|
303
|
+
sectionElement(element, "a").dispatchEvent(new window.Event("animationend", { bubbles: true }));
|
|
304
|
+
await vi.advanceTimersByTimeAsync(0);
|
|
305
|
+
const b = sectionElement(element, "b");
|
|
306
|
+
expect(b.textContent).toContain("B.");
|
|
307
|
+
expect(transition(b)).toEqual({ name: "fade", time: "" });
|
|
308
|
+
expect(element.querySelector(".squiffy-clear-stack [data-section='a']")).not.toBeNull();
|
|
309
|
+
|
|
310
|
+
// In a passage, the passage's own transitions
|
|
311
|
+
await clickWithoutWaiting(element, "look");
|
|
312
|
+
expect(leaving(sectionElement(element, "b"))).toEqual({ name: "slide-up", time: "" });
|
|
313
|
+
await vi.runAllTimersAsync();
|
|
314
|
+
const look = passageElement(element, "look");
|
|
315
|
+
expect(look.textContent).toBe("Looking.");
|
|
316
|
+
expect(transition(look)).toEqual({ name: "zoom", time: "" });
|
|
317
|
+
expect(element.querySelectorAll(".squiffy-clear-stack .squiffy-output-passage")).toHaveLength(0);
|
|
318
|
+
});
|
|
319
|
+
|
|
320
|
+
test("A slide moves the way it's named, arriving or leaving", async () => {
|
|
321
|
+
const { readFileSync } = await import("fs");
|
|
322
|
+
const style = document.createElement("style");
|
|
323
|
+
style.textContent = readFileSync(new URL("./squiffy.runtime.css", import.meta.url), "utf8");
|
|
324
|
+
document.head.appendChild(style);
|
|
325
|
+
|
|
326
|
+
const animation = (classes: string) => {
|
|
327
|
+
const el = document.createElement("div");
|
|
328
|
+
el.className = classes;
|
|
329
|
+
document.body.appendChild(el);
|
|
330
|
+
const computed = getComputedStyle(el);
|
|
331
|
+
const result = `${computed.animationName} ${computed.animationDirection || "normal"}`;
|
|
332
|
+
el.remove();
|
|
333
|
+
return result;
|
|
334
|
+
};
|
|
335
|
+
// Arriving, slide-left comes in from the right, and leaving, goes off to the left, by playing
|
|
336
|
+
// the animation from the left backwards
|
|
337
|
+
expect(animation("squiffy-transition slide-left")).toBe("squiffy-transition-from-right normal");
|
|
338
|
+
expect(animation("squiffy-transition squiffy-leave slide-left")).toBe("squiffy-transition-from-left reverse");
|
|
339
|
+
expect(animation("squiffy-transition slide-up")).toBe("squiffy-transition-from-below normal");
|
|
340
|
+
expect(animation("squiffy-transition squiffy-leave slide-up")).toBe("squiffy-transition-from-above reverse");
|
|
341
|
+
// Others play backwards to leave
|
|
342
|
+
expect(animation("squiffy-transition squiffy-leave zoom")).toBe("squiffy-transition-zoom reverse");
|
|
343
|
+
});
|
package/src/types.plugins.ts
CHANGED
|
@@ -22,7 +22,14 @@ export interface PluginHost {
|
|
|
22
22
|
getSectionText(name: string): string | null;
|
|
23
23
|
getPassageText(name: string): string | null;
|
|
24
24
|
processText: (text: string, inline: boolean) => string;
|
|
25
|
+
// Rewrites asset URLs (src, srcset, poster, style url()) in already-rendered HTML using the
|
|
26
|
+
// resolveAssetUrl init option. Use this for HTML a plugin inserts without going through
|
|
27
|
+
// processText. Returns the HTML unchanged if no resolveAssetUrl was given.
|
|
28
|
+
resolveAssetsInHtml: (html: string) => string;
|
|
25
29
|
addTransition: (fn: () => Promise<void>) => void;
|
|
30
|
+
// Runs the plugins' onWrite on HTML a plugin has put in the output itself, so that what's in
|
|
31
|
+
// it works as it would in any other text, e.g. an {{#animate}} starts
|
|
32
|
+
written: (el: HTMLElement) => void;
|
|
26
33
|
animation: Animation;
|
|
27
34
|
on<E extends keyof SquiffyEventMap>(
|
|
28
35
|
event: E,
|
package/src/types.ts
CHANGED
|
@@ -7,6 +7,25 @@ export interface SquiffyInitOptions {
|
|
|
7
7
|
persist?: boolean,
|
|
8
8
|
storyId?: string,
|
|
9
9
|
onSet?: (attribute: string, value: any) => void,
|
|
10
|
+
/**
|
|
11
|
+
* Maps an asset path used in the story (e.g. "cat.png" in an img src) to the URL it should be
|
|
12
|
+
* loaded from. Applied to src, srcset and poster attributes, and url() in inline styles, of
|
|
13
|
+
* rendered output. Absolute URLs (http:, https:, data:, blob: etc. and protocol-relative) are
|
|
14
|
+
* left alone. When not provided, paths are used as they are.
|
|
15
|
+
*/
|
|
16
|
+
resolveAssetUrl?: (path: string) => string,
|
|
17
|
+
/**
|
|
18
|
+
* The page's text, for a story in another language: squiffy.json's "strings", by the same
|
|
19
|
+
* names. Used for the text of {{restart}} and {{saves}} links (#452), and the dialogs they
|
|
20
|
+
* open when the page doesn't handle them itself. Anything left out is in English.
|
|
21
|
+
*/
|
|
22
|
+
strings?: Partial<Record<string, string>>,
|
|
23
|
+
/**
|
|
24
|
+
* The values of the story's persistent attributes (squiffy.json's "persistent", #539) to start
|
|
25
|
+
* with, in place of those kept in the browser: e.g. the CLI's --play carrying them from one run
|
|
26
|
+
* to the next. getPersistent() gives them back.
|
|
27
|
+
*/
|
|
28
|
+
persistent?: Record<string, unknown>,
|
|
10
29
|
}
|
|
11
30
|
|
|
12
31
|
export interface SquiffySettings {
|
|
@@ -15,14 +34,59 @@ export interface SquiffySettings {
|
|
|
15
34
|
onSet: (attribute: string, value: any) => void,
|
|
16
35
|
}
|
|
17
36
|
|
|
37
|
+
// Where to start a story, instead of its start section or a saved game
|
|
38
|
+
export interface StartAt {
|
|
39
|
+
section: string;
|
|
40
|
+
// A passage in that section, shown after the section
|
|
41
|
+
passage?: string;
|
|
42
|
+
}
|
|
43
|
+
|
|
18
44
|
export interface SquiffyApi {
|
|
19
|
-
|
|
45
|
+
// Starts the story: from startAt if it's given (ignoring any saved game), otherwise from the
|
|
46
|
+
// saved game, or the story's start section.
|
|
47
|
+
begin: (startAt?: StartAt) => Promise<void>;
|
|
20
48
|
restart: () => void;
|
|
21
49
|
get: (attribute: string) => any;
|
|
22
50
|
set: (attribute: string, value: any) => void;
|
|
23
51
|
clickLink: (link: HTMLElement) => Promise<boolean>;
|
|
24
52
|
update: (story: Story) => void;
|
|
25
53
|
goBack: () => void;
|
|
54
|
+
// Whether goBack() would go anywhere, e.g. to enable a Back button. canGoBackChanged says when it changes.
|
|
55
|
+
canGoBack: () => boolean;
|
|
56
|
+
// The game as it is now, to keep and load again later with loadSave()
|
|
57
|
+
getSave: () => SavedGame;
|
|
58
|
+
// Carries on from a saved game, in place of the game as it is now. A save from a different
|
|
59
|
+
// story (by its squiffy.json "id") isn't loaded.
|
|
60
|
+
loadSave: (save: SavedGame) => Promise<LoadSaveResult>;
|
|
61
|
+
// A passage in the master section [[]], rendered as HTML with the attributes as they are now,
|
|
62
|
+
// for a panel beside the story or a dialog (#14, #443). It changes nothing: {{set}} and the
|
|
63
|
+
// like are ignored, its @set and JavaScript don't run, and its links are disabled.
|
|
64
|
+
renderPassage: (name: string) => string;
|
|
65
|
+
// Whether the story's music and sounds are muted (#444). It's remembered for the story when
|
|
66
|
+
// persist is on, like the light or dark theme.
|
|
67
|
+
isMuted: () => boolean;
|
|
68
|
+
setMuted: (muted: boolean) => void;
|
|
69
|
+
// Whether the story plays music or sounds: it names some files, or has played one. The
|
|
70
|
+
// "sound" event says when something plays.
|
|
71
|
+
usesSound: () => boolean;
|
|
72
|
+
// The story's player settings (squiffy.json's "settings", #452), which the Settings dialog shows
|
|
73
|
+
getSettings: () => PlayerSetting[];
|
|
74
|
+
// A setting's value, as the story reads it with settings.name: its default if the player
|
|
75
|
+
// hasn't changed it
|
|
76
|
+
getSetting: (name: string) => SettingValue | null;
|
|
77
|
+
// Changes a setting, as the player does in the Settings dialog. A value that isn't one the
|
|
78
|
+
// setting can have is ignored. It's remembered for the story when persist is on, and going
|
|
79
|
+
// back, restarting or loading a saved game doesn't change it.
|
|
80
|
+
setSetting: (name: string, value: SettingValue) => void;
|
|
81
|
+
// Puts every setting back to its default
|
|
82
|
+
resetSettings: () => void;
|
|
83
|
+
// The values of the story's persistent attributes (squiffy.json's "persistent", #539), by
|
|
84
|
+
// name: those the story has set. They aren't in getSave(), as loading a game leaves them alone.
|
|
85
|
+
getPersistent: () => Record<string, unknown>;
|
|
86
|
+
// Clears persistent attributes, as {{forget}} does: the ones named, or all of them
|
|
87
|
+
forget: (names?: string[]) => void;
|
|
88
|
+
// Stops the story's music and sounds for good, when it's being replaced, e.g. in the editor's preview
|
|
89
|
+
dispose: () => void;
|
|
26
90
|
|
|
27
91
|
on<E extends keyof SquiffyEventMap>(
|
|
28
92
|
event: E,
|
|
@@ -40,6 +104,41 @@ export interface SquiffyApi {
|
|
|
40
104
|
): () => void;
|
|
41
105
|
}
|
|
42
106
|
|
|
107
|
+
// The events a story's own scripts can listen for (#528). The others are for the page around the
|
|
108
|
+
// story: a handler for restartRequested, say, would stop the page asking before restarting.
|
|
109
|
+
export type SquiffyScriptEvent = "navigated" | "set" | "settingChanged";
|
|
110
|
+
|
|
111
|
+
// What a story's own scripts (.js files added to the page, or @import-ed) get with the
|
|
112
|
+
// squiffy:ready event, which the story's element sends, bubbling up to document, when the story
|
|
113
|
+
// has been set up and before it starts (#528):
|
|
114
|
+
//
|
|
115
|
+
// document.addEventListener("squiffy:ready", ({ detail: squiffy }) => {
|
|
116
|
+
// squiffy.on("navigated", ({ section }) => { ... });
|
|
117
|
+
// });
|
|
118
|
+
//
|
|
119
|
+
// Its get, set and story are the same as a section's JavaScript gets.
|
|
120
|
+
export interface SquiffyScriptApi {
|
|
121
|
+
get: (attribute: string) => any;
|
|
122
|
+
set: (attribute: string, value: any) => void;
|
|
123
|
+
story: {
|
|
124
|
+
go: (section: string) => Promise<void>;
|
|
125
|
+
seen: (sectionOrPassage: string) => boolean;
|
|
126
|
+
visits: (sectionOrPassage: string) => number;
|
|
127
|
+
// How many turns ago it was last visited: 0 if the player is there now, -1 if never (#540)
|
|
128
|
+
lastVisited: (sectionOrPassage: string) => number;
|
|
129
|
+
passages: (section?: string, filter?: TagFilter) => string[];
|
|
130
|
+
sections: (filter?: TagFilter) => string[];
|
|
131
|
+
tags: (name?: string) => string[];
|
|
132
|
+
};
|
|
133
|
+
// A player setting's value (squiffy.json's "settings"), as the story reads it with settings.name
|
|
134
|
+
getSetting: (name: string) => SettingValue | null;
|
|
135
|
+
// The story's element
|
|
136
|
+
element: HTMLElement;
|
|
137
|
+
on<E extends SquiffyScriptEvent>(event: E, handler: SquiffyEventHandler<E>): () => void;
|
|
138
|
+
off<E extends SquiffyScriptEvent>(event: E, handler: SquiffyEventHandler<E>): void;
|
|
139
|
+
once<E extends SquiffyScriptEvent>(event: E, handler: SquiffyEventHandler<E>): () => void;
|
|
140
|
+
}
|
|
141
|
+
|
|
43
142
|
// Previous versions of Squiffy had "squiffy", "get" and "set" as globals - we now pass these directly into JS functions.
|
|
44
143
|
// We may tidy up this API at some point, though that would be a breaking change.
|
|
45
144
|
interface SquiffyJsFunctionApi {
|
|
@@ -51,9 +150,27 @@ interface SquiffyJsFunctionApi {
|
|
|
51
150
|
story: {
|
|
52
151
|
go: (section: string) => void;
|
|
53
152
|
seen: (sectionOrPassage: string) => boolean;
|
|
153
|
+
visits: (sectionOrPassage: string) => number;
|
|
154
|
+
// How many turns ago it was last visited: 0 if the player is there now, -1 if never (#540)
|
|
155
|
+
lastVisited: (sectionOrPassage: string) => number;
|
|
156
|
+
// The passages of a section ("" for the master section), or with no section, the
|
|
157
|
+
// current section's and the master section's, leaving out @1, @last and @after (#527)
|
|
158
|
+
passages: (section?: string, filter?: TagFilter) => string[];
|
|
159
|
+
// The story's sections, apart from the master section
|
|
160
|
+
sections: (filter?: TagFilter) => string[];
|
|
161
|
+
// A passage's or section's @tag tags, or the current section's
|
|
162
|
+
tags: (name?: string) => string[];
|
|
54
163
|
};
|
|
55
164
|
}
|
|
56
165
|
|
|
166
|
+
// Which sections or passages squiffy.story.passages() and sections() list, by their @tag tags (#527)
|
|
167
|
+
export interface TagFilter {
|
|
168
|
+
// Only those with all of these tags (separated by spaces, or a list)
|
|
169
|
+
tagged?: string | string[];
|
|
170
|
+
// Only those with none of these tags
|
|
171
|
+
untagged?: string | string[];
|
|
172
|
+
}
|
|
173
|
+
|
|
57
174
|
export interface Story {
|
|
58
175
|
js: ((
|
|
59
176
|
squiffy: SquiffyJsFunctionApi,
|
|
@@ -62,13 +179,82 @@ export interface Story {
|
|
|
62
179
|
) => void)[];
|
|
63
180
|
start: string;
|
|
64
181
|
id?: string | null;
|
|
182
|
+
// squiffy.json's "id", which a saved game is checked against
|
|
183
|
+
projectId?: string;
|
|
65
184
|
uiJsIndex?: number;
|
|
185
|
+
// The sound files the story names (#444), to load before they're needed
|
|
186
|
+
audio?: string[];
|
|
187
|
+
// Whether @set and link setters take expressions, with the same rules as {{#if}}: attributes
|
|
188
|
+
// by name, and text in quotes. True for a story with a squiffy.json (#373).
|
|
189
|
+
expressions?: boolean;
|
|
190
|
+
// squiffy.json's "panels": passages shown beside the story, or in a dialog from a button
|
|
191
|
+
panels?: Panel[];
|
|
192
|
+
// squiffy.json's "settings": options the player can change, which the story reads as settings.name
|
|
193
|
+
settings?: PlayerSetting[];
|
|
194
|
+
// squiffy.json's "persistent": attributes that belong to the player rather than the
|
|
195
|
+
// playthrough (#539). Restarting, going back and loading a saved game leave them as they are.
|
|
196
|
+
persistent?: string[];
|
|
66
197
|
sections: Record<string, Section>;
|
|
67
198
|
}
|
|
68
199
|
|
|
200
|
+
// The icons a panel's button can have, in place of its label
|
|
201
|
+
export const PANEL_ICONS = ["bag", "person", "map", "help", "info", "list", "book", "star", "heart"] as const;
|
|
202
|
+
export type PanelIcon = typeof PANEL_ICONS[number];
|
|
203
|
+
|
|
204
|
+
// A passage in the master section that's always on screen, rendered again as the story goes on:
|
|
205
|
+
// beside the story ("side"), or in a dialog that a button in the header opens ("button").
|
|
206
|
+
export interface Panel {
|
|
207
|
+
passage: string;
|
|
208
|
+
// The button's text, or its tooltip if it has an icon. A side panel's button only shows on
|
|
209
|
+
// screens too narrow for the panel.
|
|
210
|
+
label: string;
|
|
211
|
+
// "button" if it's left out
|
|
212
|
+
position?: "side" | "button";
|
|
213
|
+
icon?: PanelIcon;
|
|
214
|
+
}
|
|
215
|
+
|
|
216
|
+
// A player setting (#452), from squiffy.json's "settings": "toggle" is on or off, "list" is one of
|
|
217
|
+
// its options, and "range" a number from min to max
|
|
218
|
+
export type PlayerSetting =
|
|
219
|
+
| PlayerSettingBase & { type: "toggle"; default?: boolean }
|
|
220
|
+
| PlayerSettingBase & { type: "list"; options: PlayerSettingOption[]; default?: string }
|
|
221
|
+
| PlayerSettingBase & { type: "range"; min: number; max: number; step?: number; default?: number };
|
|
222
|
+
|
|
223
|
+
interface PlayerSettingBase {
|
|
224
|
+
// How the story refers to it: settings.name
|
|
225
|
+
name: string;
|
|
226
|
+
// What the Settings dialog calls it
|
|
227
|
+
label: string;
|
|
228
|
+
// More about it, shown under the label
|
|
229
|
+
description?: string;
|
|
230
|
+
}
|
|
231
|
+
|
|
232
|
+
export interface PlayerSettingOption {
|
|
233
|
+
// What the story reads
|
|
234
|
+
value: string;
|
|
235
|
+
// What the Settings dialog shows
|
|
236
|
+
label: string;
|
|
237
|
+
}
|
|
238
|
+
|
|
239
|
+
export type SettingValue = boolean | string | number;
|
|
240
|
+
|
|
69
241
|
export interface Section {
|
|
70
242
|
text?: string;
|
|
71
243
|
clear?: boolean;
|
|
244
|
+
// @music (#444): the file to play, or null to stop it
|
|
245
|
+
music?: string | null;
|
|
246
|
+
// @sound: files to play once, in order, with "stop" for @sound stop
|
|
247
|
+
sounds?: string[];
|
|
248
|
+
// @class (#449): classes on the story's element while this is the current section
|
|
249
|
+
classes?: string[];
|
|
250
|
+
// @tag (#527): tags the story can list sections by
|
|
251
|
+
tags?: string[];
|
|
252
|
+
// @transition (#489): how it appears, or "none", and how long that takes in milliseconds
|
|
253
|
+
transition?: string;
|
|
254
|
+
transitionTime?: number;
|
|
255
|
+
// @leave: how the old text goes when this clears the screen, or "none", and how long that takes
|
|
256
|
+
leave?: string;
|
|
257
|
+
leaveTime?: number;
|
|
72
258
|
attributes?: string[],
|
|
73
259
|
jsIndex?: number;
|
|
74
260
|
passages?: Record<string, Passage>;
|
|
@@ -78,6 +264,44 @@ export interface Section {
|
|
|
78
264
|
export interface Passage {
|
|
79
265
|
text?: string;
|
|
80
266
|
clear?: boolean;
|
|
267
|
+
// @music (#444): the file to play, or null to stop it
|
|
268
|
+
music?: string | null;
|
|
269
|
+
// @sound: files to play once, in order, with "stop" for @sound stop
|
|
270
|
+
sounds?: string[];
|
|
271
|
+
// @class (#449): classes added to the section's when this passage is shown
|
|
272
|
+
classes?: string[];
|
|
273
|
+
// @tag (#527): tags the story can list passages by
|
|
274
|
+
tags?: string[];
|
|
275
|
+
// @transition (#489): how it appears, or "none", and how long that takes in milliseconds
|
|
276
|
+
transition?: string;
|
|
277
|
+
transitionTime?: number;
|
|
278
|
+
// @leave: how the old text goes when this clears the screen, or "none", and how long that takes
|
|
279
|
+
leave?: string;
|
|
280
|
+
leaveTime?: number;
|
|
281
|
+
// @repeat: its links stay clickable, and clicking one doesn't count towards @1, @2... and @last (#104)
|
|
282
|
+
repeat?: boolean;
|
|
81
283
|
attributes?: string[];
|
|
82
284
|
jsIndex?: number;
|
|
83
|
-
}
|
|
285
|
+
}
|
|
286
|
+
// A saved game, from SquiffyApi.getSave(). It's JSON, so it can be kept as text or in a file.
|
|
287
|
+
export interface SavedGame {
|
|
288
|
+
format: "squiffy-save";
|
|
289
|
+
version: 1;
|
|
290
|
+
// The story's squiffy.json "id", if it has one
|
|
291
|
+
storyId: string | null;
|
|
292
|
+
// Where the player was
|
|
293
|
+
section: string | null;
|
|
294
|
+
passage: string | null;
|
|
295
|
+
// The start of the text the player was reading, to tell saves apart by
|
|
296
|
+
summary: string;
|
|
297
|
+
// When it was saved, as an ISO date
|
|
298
|
+
savedAt: string;
|
|
299
|
+
// Every attribute, including the text on screen (_output)
|
|
300
|
+
state: Record<string, unknown>;
|
|
301
|
+
}
|
|
302
|
+
|
|
303
|
+
export type LoadSaveResult =
|
|
304
|
+
| { success: true }
|
|
305
|
+
// notASave: it isn't a saved game, or it's from a newer version of Squiffy.
|
|
306
|
+
// wrongStory: it's from a different story.
|
|
307
|
+
| { success: false; error: "notASave" | "wrongStory" };
|