snack-sdk 3.8.0 → 3.9.0

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/CHANGELOG.md +22 -0
  2. package/build/DependencyResolver.d.ts +26 -26
  3. package/build/DependencyResolver.js +258 -258
  4. package/build/DevSession.d.ts +20 -20
  5. package/build/DevSession.js +203 -203
  6. package/build/FileUploader.d.ts +23 -23
  7. package/build/FileUploader.js +174 -174
  8. package/build/Logger.d.ts +11 -11
  9. package/build/Logger.js +33 -33
  10. package/build/Session.d.ts +301 -301
  11. package/build/Session.js +1172 -1171
  12. package/build/Session.js.map +1 -1
  13. package/build/State.d.ts +16 -16
  14. package/build/State.js +90 -90
  15. package/build/WantedVersions.d.ts +40 -17
  16. package/build/WantedVersions.js +156 -93
  17. package/build/WantedVersions.js.map +1 -1
  18. package/build/defaultConfig.d.ts +12 -12
  19. package/build/defaultConfig.js +29 -29
  20. package/build/index.d.ts +7 -7
  21. package/build/index.js +30 -30
  22. package/build/transports/CodeMessageBuilder.d.ts +31 -31
  23. package/build/transports/CodeMessageBuilder.js +196 -196
  24. package/build/transports/Protocol.d.ts +64 -64
  25. package/build/transports/Protocol.js +2 -2
  26. package/build/transports/Transport.d.ts +28 -27
  27. package/build/transports/Transport.js +303 -298
  28. package/build/transports/Transport.js.map +1 -1
  29. package/build/transports/index.d.ts +3 -3
  30. package/build/transports/index.js +22 -22
  31. package/build/transports/types.d.ts +63 -63
  32. package/build/transports/types.js +2 -2
  33. package/build/transports/webPlayer.d.ts +12 -12
  34. package/build/transports/webPlayer.js +70 -70
  35. package/build/types.d.ts +185 -185
  36. package/build/types.js +2 -2
  37. package/build/utils.d.ts +17 -17
  38. package/build/utils.js +68 -68
  39. package/package.json +11 -4
  40. package/src/DependencyResolver.ts +0 -218
  41. package/src/DevSession.ts +0 -159
  42. package/src/FileUploader.ts +0 -135
  43. package/src/Logger.ts +0 -33
  44. package/src/Session.ts +0 -1293
  45. package/src/State.ts +0 -98
  46. package/src/WantedVersions.ts +0 -57
  47. package/src/defaultConfig.ts +0 -33
  48. package/src/index.ts +0 -59
  49. package/src/transports/CodeMessageBuilder.ts +0 -226
  50. package/src/transports/Protocol.ts +0 -78
  51. package/src/transports/Transport.ts +0 -270
  52. package/src/transports/index.ts +0 -8
  53. package/src/transports/types.ts +0 -89
  54. package/src/transports/webPlayer.ts +0 -93
  55. package/src/types.ts +0 -223
  56. package/src/utils.ts +0 -71
  57. package/tsconfig.json +0 -28
package/src/Session.ts DELETED
@@ -1,1293 +0,0 @@
1
- import mapValues from 'lodash/mapValues';
2
- import nullthrows from 'nullthrows';
3
- import {
4
- SDKVersion,
5
- SnackDependencies,
6
- SnackDependency,
7
- SnackFile,
8
- SnackFiles,
9
- isModulePreloaded,
10
- validateSDKVersion,
11
- } from 'snack-content';
12
-
13
- import DependencyResolver, {
14
- DependencyResolverCallback,
15
- verifyDependency,
16
- getMissingDependencies,
17
- getPackageName,
18
- } from './DependencyResolver';
19
- import DevSession from './DevSession';
20
- import FileUploader, { FileUploaderCallback } from './FileUploader';
21
- import { Logger, createLogger } from './Logger';
22
- import * as State from './State';
23
- import { WantedDependencyVersions, WantedDependencyVersionsCallback } from './WantedVersions';
24
- import defaultConfig, { SnackIdentityState } from './defaultConfig';
25
- import {
26
- createTransport,
27
- SnackTransport,
28
- SnackTransportEvent,
29
- SnackTransportOptions,
30
- } from './transports';
31
- import {
32
- ProtocolIncomingMessage,
33
- ProtocolOutgoingMessage,
34
- ProtocolConsoleMessage,
35
- ProtocolErrorMessage,
36
- ProtocolReloadMessage,
37
- ProtocolStatusMessage,
38
- ProtocolRequestStatusMessage,
39
- } from './transports/Protocol';
40
- import { createWebPlayerTransport, getWebPlayerIFrameURL } from './transports/webPlayer';
41
- import {
42
- SnackState,
43
- SnackUser,
44
- SnackSendBeaconRequest,
45
- SnackLogEvent,
46
- SnackListenerSubscription,
47
- SnackConnectedClients,
48
- SnackWindowRef,
49
- } from './types';
50
- import { createChannel, fetch, createURL, createError, createUserHeader } from './utils';
51
-
52
- export type SnackOptions = {
53
- sdkVersion?: SDKVersion;
54
- name?: string;
55
- description?: string;
56
- dependencies?: SnackDependencies;
57
- files?: SnackFiles;
58
- apiURL?: string;
59
- host?: string;
60
- snackagerURL?: string;
61
- verbose?: boolean;
62
- disabled?: boolean;
63
- online?: boolean;
64
- channel?: string; // Will be randomly generated if not provided
65
- deviceId?: string;
66
- transports?: { [id: string]: SnackTransport };
67
- createTransport?: (options: SnackTransportOptions) => SnackTransport;
68
- codeChangesDelay?: number;
69
- reloadTimeout?: number;
70
- previewTimeout?: number;
71
- user?: SnackUser;
72
- id?: string;
73
- snackId?: string;
74
- accountSnackId?: string;
75
- webPlayerURL?: string;
76
- webPreviewRef?: SnackWindowRef;
77
- };
78
-
79
- export type SnackSaveOptions = {
80
- isDraft?: boolean;
81
- ignoreUser?: boolean;
82
- };
83
-
84
- export type SnackStateListener = (state: SnackState, prevState: SnackState) => any;
85
- export type SnackLogListener = (log: SnackLogEvent) => any;
86
-
87
- export default class Snack {
88
- private state: SnackState;
89
- private stateListeners: Set<SnackStateListener> = new Set();
90
- private logListeners: Set<SnackLogListener> = new Set();
91
- private readonly createTransport: (options: SnackTransportOptions) => SnackTransport;
92
- private readonly logger?: Logger;
93
- private readonly apiURL: string;
94
- private readonly host: string;
95
- private readonly dependencyResolver: DependencyResolver;
96
- private readonly fileUploader: FileUploader;
97
- private readonly DevSession: DevSession;
98
- private wantedDependencyVersions: WantedDependencyVersions;
99
- private codeChangesDelay: number;
100
- private codeChangesTimer: any;
101
- private readonly reloadTimeout: number;
102
- private readonly previewTimeout: number;
103
- private readonly webPlayerURL: string;
104
- private pruneConnectionsTimer: any;
105
- private readonly transportListeners: {
106
- [key: string]: (event: any) => void;
107
- } = {};
108
-
109
- constructor(options: SnackOptions) {
110
- const channel = createChannel(options.channel);
111
- const sdkVersion = validateSDKVersion(options.sdkVersion ?? defaultConfig.sdkVersion);
112
- const dependencies = options.dependencies ? { ...options.dependencies } : {};
113
- this.apiURL = options.apiURL ?? defaultConfig.apiURL;
114
- this.host = options.host ?? new URL(this.apiURL).host;
115
- this.logger = options.verbose ? createLogger(true) : undefined;
116
- this.codeChangesDelay = options.codeChangesDelay ?? 0;
117
- this.reloadTimeout = options.reloadTimeout ?? 0;
118
- this.previewTimeout = options.previewTimeout ?? 10000;
119
- this.createTransport = options.createTransport ?? createTransport;
120
- this.webPlayerURL = options.webPlayerURL ?? defaultConfig.webPlayerURL;
121
-
122
- let transports = options.transports ?? {};
123
- if (options.online) {
124
- transports = State.addObject(
125
- transports,
126
- 'pubnub',
127
- this.createTransport({
128
- name: 'pubnub',
129
- channel,
130
- verbose: options.verbose,
131
- apiURL: this.apiURL,
132
- })
133
- );
134
- }
135
- if (options.webPreviewRef) {
136
- transports = State.addObject(
137
- transports,
138
- 'webplayer',
139
- createWebPlayerTransport({
140
- ref: options.webPreviewRef,
141
- verbose: options.verbose,
142
- createTransport: this.createTransport,
143
- window: nullthrows(typeof window !== 'undefined' ? window : (global as any)),
144
- webPlayerURL: this.webPlayerURL,
145
- })
146
- );
147
- }
148
-
149
- this.state = this.updateDerivedState(
150
- {
151
- disabled: !!options.disabled,
152
- unsaved: false,
153
- name: options.name ?? '',
154
- description: options.description ?? '',
155
- sdkVersion,
156
- files: options.files ?? {},
157
- dependencies,
158
- missingDependencies: getMissingDependencies(dependencies, sdkVersion),
159
- connectedClients: {},
160
- transports,
161
- user: options.user,
162
- id: options.id,
163
- saveURL: options.id ? createURL(this.host, sdkVersion, undefined, options.id) : undefined,
164
- savedSDKVersion: options.id ? sdkVersion : undefined,
165
- online: false,
166
- url: createURL(this.host, sdkVersion, channel, options.id),
167
- channel,
168
- deviceId: options.deviceId,
169
- snackId: options.snackId,
170
- accountSnackId: options.accountSnackId,
171
- },
172
- SnackIdentityState
173
- );
174
- this.state.unsaved = false;
175
-
176
- this.wantedDependencyVersions = new WantedDependencyVersions({
177
- logger: this.logger,
178
- callback: this.onWantedDependencyVersions,
179
- });
180
- this.dependencyResolver = new DependencyResolver({
181
- snackagerURL: options.snackagerURL ?? defaultConfig.snackagerURL,
182
- logger: this.logger,
183
- callback: this.onDependencyResolved,
184
- });
185
- this.fileUploader = new FileUploader({
186
- apiURL: this.apiURL,
187
- logger: this.logger,
188
- callback: this.onFileUploaded,
189
- });
190
- this.DevSession = new DevSession({
191
- apiURL: this.apiURL,
192
- logger: this.logger,
193
- onSendBeaconCloseRequest: this.onDevSessionSendBeaconCloseRequest,
194
- });
195
- this.logger?.info('Snack created', this.getState());
196
- this.onStateChanged(this.state, SnackIdentityState);
197
- }
198
-
199
- //
200
- // Content
201
- //
202
-
203
- /**
204
- * Sets the Expo SDK version.
205
- * @param sdkVersion Valid SDK version (e.g. "38.0.0")
206
- */
207
- setSDKVersion(sdkVersion: SDKVersion) {
208
- validateSDKVersion(sdkVersion);
209
- return this.setState((state) =>
210
- state.sdkVersion !== sdkVersion
211
- ? {
212
- sdkVersion,
213
- missingDependencies: getMissingDependencies(
214
- state.dependencies,
215
- sdkVersion,
216
- state.wantedDependencyVersions
217
- ),
218
- }
219
- : null
220
- );
221
- }
222
-
223
- /**
224
- * Sets the name of the Snack.
225
- * @param name E.g. "conspicious orange"
226
- */
227
- setName(name: string) {
228
- return this.setState((state) => (state.name !== name ? { name } : null));
229
- }
230
-
231
- /**
232
- * Sets the description of the Snack.
233
- * @param name E.g. "My awesome Snack"
234
- */
235
- setDescription(description: string) {
236
- return this.setState((state) => (state.description !== description ? { description } : null));
237
- }
238
-
239
- /**
240
- * Sets the associated user account.
241
- *
242
- * When set and `online` is true, causes this Snack to appear on the
243
- * "Recently in Development" section of all Expo clients that are signed
244
- * in with that account.
245
- */
246
- setUser(user?: SnackUser) {
247
- return this.setState((state) => (state.user !== user ? { user } : null));
248
- }
249
-
250
- /**
251
- * Sets the device-id of an Expo client. When set and `online` is true, causes this
252
- * Snack to appear on the "Recently in Development" section of that Expo client.
253
- */
254
- setDeviceId(deviceId?: string) {
255
- return this.setState((state) => (state.deviceId !== deviceId ? { deviceId } : null));
256
- }
257
-
258
- /**
259
- * Sets the focus to this Snack.
260
- *
261
- * Causes this Snack to be moved to the top of the "Recently in Development" list
262
- * in the Expo client.
263
- */
264
- setFocus() {
265
- this.DevSession.setFocus(this.state);
266
- }
267
-
268
- /**
269
- * Sets the delay that is used before sending code updates to the connected clients.
270
- * Use this method to set the "debounce" timeout to use for sending code changes
271
- * over pubnub.
272
- *
273
- * ```
274
- * -1 = Disable automatic sending of code changes (use `sendCodeChanges` to trigger the send)
275
- * 0 = Code changes are sent immediately to the connected clients
276
- * 1..n = Code changes are debounced and sent after the wait time
277
- * ```
278
- *
279
- * @param delay Timeout in milliseconds (or -1 to disable automatic code updates)
280
- */
281
- setCodeChangesDelay(delay: number) {
282
- if (this.codeChangesDelay !== delay) {
283
- this.codeChangesDelay = delay;
284
- this._sendCodeChangesDebounced(this.state);
285
- }
286
- }
287
-
288
- /**
289
- * Sends any pending code changes to the connected clients.
290
- * No changes are send if all clients are already up to date.
291
- */
292
- sendCodeChanges() {
293
- this._sendCodeChangesDebounced(this.state, true);
294
- }
295
-
296
- private _sendCodeChangesDebounced(state: SnackState, immediate?: boolean) {
297
- // Clear the debounce timer
298
- if (this.codeChangesTimer) {
299
- clearTimeout(this.codeChangesTimer);
300
- this.codeChangesTimer = undefined;
301
- }
302
-
303
- // Schedule debounced update
304
- if (!immediate && this.codeChangesDelay > 0) {
305
- this.codeChangesTimer = setTimeout(
306
- () => this._sendCodeChangesDebounced(state, true),
307
- this.codeChangesDelay
308
- );
309
- return;
310
- } else if (!immediate && this.codeChangesDelay < 0) {
311
- return;
312
- }
313
-
314
- // Send the changes
315
- const { transports, files, dependencies, sdkVersion } = state;
316
- for (const key in transports) {
317
- transports[key].postMessage({
318
- type: 'update_code',
319
- data: {
320
- files,
321
- dependencies,
322
- sdkVersion,
323
- },
324
- });
325
- }
326
- }
327
-
328
- //
329
- // Save
330
- //
331
-
332
- /**
333
- * Uploads the current code to Expo's servers and return a url that points to that version of the code.
334
- */
335
- async saveAsync(options?: SnackSaveOptions) {
336
- const prevState = this.state;
337
-
338
- // Wait for any pending asset uploads the complete before saving
339
- await this.fileUploader.waitForCompletion();
340
-
341
- const { name, description, sdkVersion, files, dependencies, user } = this.state;
342
-
343
- try {
344
- const payload: any = {
345
- manifest: {
346
- sdkVersion,
347
- name,
348
- description,
349
- dependencies: mapValues(dependencies, (dep) => dep.version),
350
- },
351
- code: mapValues(files, (file: any) => {
352
- file = { ...file };
353
- delete file.error;
354
- return file;
355
- }),
356
- dependencies: mapValues(dependencies, (dep) => {
357
- dep = { ...dep };
358
- delete dep.error;
359
- return dep;
360
- }),
361
- isDraft: options?.isDraft ?? false,
362
- };
363
-
364
- this.logger?.info('Saving...', payload);
365
-
366
- const previewPromise = this.getPreviewAsync();
367
-
368
- const url = `${this.apiURL}/--/api/v2/snack/save`;
369
- const response = await fetch(url, {
370
- method: 'POST',
371
- body: JSON.stringify(payload),
372
- headers: {
373
- 'Content-Type': 'application/json',
374
- ...(options?.ignoreUser ? {} : createUserHeader(user)),
375
- },
376
- });
377
- const data = await response.json();
378
- if (!data?.id) {
379
- throw new Error(data.errors?.[0]?.message || 'Failed to save');
380
- }
381
-
382
- this.logger?.info('Saved', data);
383
-
384
- const id: string = data.id;
385
- const saveURL = createURL(this.host, sdkVersion, undefined, id);
386
- const hashId: string | undefined = data.hashId;
387
- const accountSnackId: string | undefined = data.accountSnackId;
388
- const snackId: string | undefined = data.snackId;
389
-
390
- this.setState((state) => ({
391
- id,
392
- saveURL,
393
- unsaved: State.isUnsaved(state, prevState),
394
- savedSDKVersion:
395
- options?.isDraft && state.savedSDKVersion ? state.savedSDKVersion : sdkVersion,
396
- accountSnackId,
397
- snackId,
398
- }));
399
-
400
- previewPromise.then((connectedClients) => {
401
- const conns = Object.values(connectedClients)
402
- .filter((c) => c.previewURL)
403
- .sort((a, b) => (a.previewTimestamp ?? 0) - (b.previewTimestamp ?? 0));
404
- if (conns.length) {
405
- this.uploadPreview(id, conns[0].previewURL as string, conns[0].status !== 'error');
406
- }
407
- });
408
-
409
- return {
410
- id,
411
- url: saveURL,
412
- hashId,
413
- accountSnackId,
414
- snackId,
415
- };
416
- } catch (e) {
417
- this.logger?.error(e);
418
- throw e;
419
- }
420
- }
421
-
422
- /**
423
- * Gets the URL at which the Snack can be downloaded as a zip file. Will automatically
424
- * save the Snack if it contains unsaved changes.
425
- */
426
- async getDownloadURLAsync(saveOptions?: SnackSaveOptions) {
427
- await this.fileUploader.waitForCompletion();
428
- let state = this.getState();
429
- if (!state.id || state.unsaved) {
430
- await this.saveAsync(saveOptions);
431
- state = this.getState();
432
- }
433
- return `${this.apiURL}/--/api/v2/snack/download/${state.id}`;
434
- }
435
-
436
- private async uploadPreview(id: string, previewURL: string, status: boolean) {
437
- const url = `${this.apiURL}/--/api/v2/snack/updateMetadata`;
438
- const payload = {
439
- id,
440
- previewLocation: previewURL,
441
- status: status ? 'SUCCESS' : 'FAILURE',
442
- };
443
- this.logger?.info('Uploading preview...', payload);
444
-
445
- try {
446
- const response = await fetch(url, {
447
- method: 'POST',
448
- body: JSON.stringify(payload),
449
- headers: {
450
- 'Content-Type': 'application/json',
451
- },
452
- });
453
- const data = await response.json();
454
- if (data.id) {
455
- this.logger?.info('Uploaded preview', data);
456
- } else {
457
- throw new Error(data.errors?.[0]?.message ?? 'Unknown error');
458
- }
459
- } catch (e) {
460
- this.logger?.error('Failed to upload preview', e);
461
- }
462
- }
463
-
464
- //
465
- // State
466
- //
467
-
468
- /**
469
- * Returns the current state of the Snack. This includes files, dependencies
470
- * and other meta-data about the Snack.
471
- */
472
- getState(): SnackState {
473
- return this.state;
474
- }
475
-
476
- /**
477
- * Waits for any pending operations such as running dependencies resolutions
478
- * before returning the state.
479
- */
480
- async getStateAsync() {
481
- await this.wantedDependencyVersions.waitForCompletion();
482
- await this.dependencyResolver.waitForCompletion();
483
- await this.fileUploader.waitForCompletion();
484
- return this.getState();
485
- }
486
-
487
- /**
488
- * Adds a callback for listening for any state changes.
489
- *
490
- * @example
491
- * ```
492
- * const unsubscribe = Snack.addStateListener((state, prevState) => {
493
- * if (state.name !== prevState.name) {
494
- * console.log('name changed: ', state.name);
495
- * }
496
- * });
497
- *
498
- * Snack.setName('unforgiven orange'); // // Make a change to the state
499
- *
500
- * unsubscribe(); // Remove listener
501
- * ```
502
- */
503
- addStateListener(listener: SnackStateListener): SnackListenerSubscription {
504
- this.stateListeners.add(listener);
505
- return () => this.stateListeners.delete(listener);
506
- }
507
-
508
- private setState(stateFn: (state: SnackState) => any) {
509
- const update = stateFn(this.state);
510
- if (update) {
511
- const oldState = this.state;
512
- const newState: SnackState = {
513
- ...oldState,
514
- ...update,
515
- };
516
- this.state = this.updateDerivedState(newState, oldState);
517
- this.onStateChanged(newState, oldState);
518
- this.stateListeners.forEach((listener) => listener(newState, oldState));
519
- }
520
- }
521
-
522
- private updateDerivedState(state: SnackState, prevState: SnackState): SnackState {
523
- // Set unsaved to true whenever files or dependencies change
524
- state.unsaved = state.unsaved || State.isUnsaved(state, prevState);
525
-
526
- // Update other derived states
527
- this.updateDerivedOnlineState(state, prevState);
528
- this.updateDerivedDependenciesState(state, prevState);
529
- this.updateDerivedWebPreviewState(state, prevState);
530
-
531
- return state;
532
- }
533
-
534
- private onStateChanged(state: SnackState, prevState: SnackState) {
535
- this.updateWantedDependencyVersions(state, prevState);
536
- this.updateDependencyResolver(state, prevState);
537
- this.updateFileUploader(state, prevState);
538
- this.updateTransports(state, prevState);
539
- this.DevSession.setState(state, prevState);
540
- }
541
-
542
- //
543
- // Files (code & assets)
544
- //
545
-
546
- /**
547
- * Updates code or asset files.
548
- *
549
- * Use this method to add/remove/update files and upload assets.
550
- * To remove a file specify `null` as the value of the file.
551
- *
552
- * @example
553
- * ```ts
554
- * const Snack = new Snack({
555
- * files: {
556
- * 'App.js': { type: 'CODE', contents: 'console.log("hello world!");' },
557
- * 'data.json': { type: 'CODE', contents: '{}' },
558
- * }
559
- * });
560
- *
561
- * // Add or update files
562
- * Snack.updateFiles({
563
- * 'App.js': {
564
- * type: 'CODE',
565
- * contents: 'console.log("Hello Snack!");'
566
- * }
567
- * });
568
- *
569
- * // Upload an asset
570
- * Snack.updateFiles({
571
- * 'assets/logo.png': {
572
- * type: 'ASSET',
573
- * contents: file // File, Blob or FormData
574
- * }
575
- * });
576
- *
577
- * // Add a pre-uploaded asset
578
- * Snack.updateFiles({
579
- * 'assets/expo.jpg': {
580
- * type: 'ASSET',
581
- * contents: 'https://mysite/expo.jpg'
582
- * }
583
- * });
584
- *
585
- * // Remove files
586
- * Snack.updateFiles({
587
- * 'data.json': null,
588
- * 'assets/expo.jpg': null
589
- * });
590
- * ```
591
- */
592
- updateFiles(files: { [path: string]: SnackFile | null }) {
593
- return this.setState((state) => {
594
- const newFiles = State.updateObjects(state.files, files);
595
- return newFiles !== state.files ? { files: newFiles } : null;
596
- });
597
- }
598
-
599
- /**
600
- * Helper function that uploads an asset and returns its url.
601
- */
602
- uploadAssetAsync = async (contents: File | Blob | FormData): Promise<string> => {
603
- let url: string = '';
604
- const fileUploader = new FileUploader({
605
- apiURL: this.apiURL,
606
- logger: this.logger,
607
- callback: (_request, resultURL, error) => {
608
- if (error) {
609
- throw error;
610
- } else if (resultURL) {
611
- url = resultURL;
612
- }
613
- },
614
- });
615
- fileUploader.add('asset', {
616
- type: 'ASSET',
617
- contents,
618
- });
619
- await fileUploader.waitForCompletion();
620
- return url;
621
- };
622
-
623
- private updateFileUploader(state: SnackState, prevState: SnackState) {
624
- const files = state.files;
625
- const prevFiles = prevState.files;
626
-
627
- // Stop uploading any removed or changed assets
628
- if (!prevState.disabled && ((!state.disabled && files !== prevFiles) || state.disabled)) {
629
- for (const path in prevFiles) {
630
- if (!files[path] || files[path].contents !== prevFiles[path].contents || state.disabled) {
631
- this.fileUploader.remove(path, prevFiles[path]);
632
- }
633
- }
634
- }
635
-
636
- // Start uploading any new or changed assets, or when the error is cleared
637
- if (!state.disabled && (files !== prevFiles || prevState.disabled)) {
638
- for (const path in files) {
639
- const file = files[path];
640
- if (
641
- file.type === 'ASSET' &&
642
- typeof file.contents === 'object' &&
643
- !file.error &&
644
- (prevFiles[path]?.contents !== file.contents || prevState.disabled)
645
- ) {
646
- this.fileUploader.add(path, file);
647
- }
648
- }
649
- }
650
- }
651
-
652
- private onFileUploaded: FileUploaderCallback = (request, resultURL, error) => {
653
- // When a file has been uploaded, store its url in the state. This state should be persisted
654
- // by the client so that the next time it doesn't need to be uploaded again.
655
- this.setState(({ files }) => ({
656
- files: State.addObject(files, request.path, {
657
- ...request.file,
658
- ...(resultURL ? { contents: resultURL } : {}),
659
- ...(error ? { error } : {}),
660
- }),
661
- }));
662
- };
663
-
664
- //
665
- // Dependencies
666
- //
667
-
668
- /**
669
- * Updates dependencies.
670
- *
671
- * Use this method to add/remove/update dependencies.
672
- * To remove a dependency specify `null` as the value of the key/value pair.
673
- *
674
- * @example
675
- * ```ts
676
- * const Snack = new Snack({
677
- * dependencies: {
678
- * 'react-native-paper': '~2.0.0'
679
- * }
680
- * });
681
- *
682
- * // Add dependency
683
- * Snack.updateDependencies({
684
- * 'expo-font': '9.0.0'
685
- * });
686
- *
687
- * // Remove dependency
688
- * Snack.updateDependencies({
689
- * 'expo-font': null
690
- * });
691
- * ```
692
- */
693
- updateDependencies(dependencies: { [name: string]: SnackDependency | null }) {
694
- return this.setState((state) => {
695
- const newDependencies = State.updateObjects(state.dependencies, dependencies);
696
- return newDependencies !== state.dependencies
697
- ? {
698
- dependencies: newDependencies,
699
- missingDependencies: getMissingDependencies(
700
- newDependencies,
701
- state.sdkVersion,
702
- state.wantedDependencyVersions
703
- ),
704
- }
705
- : null;
706
- });
707
- }
708
-
709
- private updateDerivedDependenciesState(state: SnackState, prevState: SnackState) {
710
- if (
711
- state.wantedDependencyVersions !== prevState.wantedDependencyVersions ||
712
- state.dependencies !== prevState.dependencies
713
- ) {
714
- for (const name in state.dependencies) {
715
- const dep = state.dependencies[name];
716
- const wantedVersion =
717
- state.wantedDependencyVersions?.[name] ??
718
- state.wantedDependencyVersions?.[getPackageName(name)] ??
719
- undefined;
720
- if (dep.wantedVersion !== wantedVersion) {
721
- state.dependencies =
722
- state.dependencies === prevState.dependencies
723
- ? { ...state.dependencies }
724
- : state.dependencies;
725
- const version =
726
- (dep.version === '*' || (dep.wantedVersion && dep.version === dep.wantedVersion)) &&
727
- wantedVersion
728
- ? wantedVersion
729
- : dep.version;
730
- state.dependencies[name] = {
731
- ...dep,
732
- version,
733
- wantedVersion,
734
- };
735
- if (dep.handle && dep.version !== version) {
736
- delete state.dependencies[name].handle;
737
- }
738
- }
739
- }
740
- }
741
-
742
- if (state.dependencies !== prevState.dependencies) {
743
- for (const name in state.dependencies) {
744
- const dep = state.dependencies[name];
745
- if (dep !== prevState.dependencies[name]) {
746
- const error = verifyDependency(name, dep.version);
747
- if (error) {
748
- state.dependencies[name] = {
749
- ...dep,
750
- error,
751
- };
752
- }
753
- }
754
- }
755
- }
756
- }
757
-
758
- private updateWantedDependencyVersions(state: SnackState, _prevState: SnackState) {
759
- if (!state.disabled && Object.keys(state.dependencies).length) {
760
- this.wantedDependencyVersions.setSDKVersion(state.sdkVersion);
761
- }
762
- }
763
-
764
- private onWantedDependencyVersions: WantedDependencyVersionsCallback = (
765
- _sdkVersion,
766
- result,
767
- error
768
- ) => {
769
- const wantedDependencyVersions = error ? {} : result;
770
- this.setState(({ dependencies, sdkVersion }) => ({
771
- wantedDependencyVersions,
772
- missingDependencies: getMissingDependencies(
773
- dependencies,
774
- sdkVersion,
775
- wantedDependencyVersions
776
- ),
777
- }));
778
- };
779
-
780
- private updateDependencyResolver(state: SnackState, prevState: SnackState) {
781
- const dependencies = state.dependencies;
782
- const prevDependencies = prevState.dependencies;
783
-
784
- // Stop resolving any removed or changed dependencies
785
- if (
786
- !prevState.disabled &&
787
- (dependencies !== prevDependencies ||
788
- state.disabled ||
789
- state.sdkVersion !== prevState.sdkVersion)
790
- ) {
791
- for (const name in prevDependencies) {
792
- if (
793
- !dependencies[name] ||
794
- dependencies[name].version !== prevDependencies[name].version ||
795
- state.disabled ||
796
- (isModulePreloaded(name, state.sdkVersion) &&
797
- !isModulePreloaded(name, prevState.sdkVersion))
798
- ) {
799
- this.dependencyResolver.remove(
800
- name,
801
- prevDependencies[name].version,
802
- prevState.sdkVersion
803
- );
804
- }
805
- }
806
- }
807
-
808
- // Add any still unresolved dependencies to the dependency resolver
809
- if (
810
- !state.disabled &&
811
- (dependencies !== prevDependencies ||
812
- prevState.disabled ||
813
- state.sdkVersion !== prevState.sdkVersion ||
814
- state.wantedDependencyVersions !== prevState.wantedDependencyVersions)
815
- ) {
816
- for (const name in dependencies) {
817
- const dependency = dependencies[name];
818
- if (
819
- !dependency.handle &&
820
- !dependency.error &&
821
- !isModulePreloaded(name, state.sdkVersion) &&
822
- !(dependency.version === '*' && !state.wantedDependencyVersions) &&
823
- (prevDependencies[name]?.version !== dependency.version ||
824
- (dependency.version === '*' && !prevState.wantedDependencyVersions) ||
825
- prevDependencies[name]?.handle ||
826
- prevDependencies[name]?.error ||
827
- prevState.disabled)
828
- ) {
829
- this.dependencyResolver.add(name, dependency.version, state.sdkVersion);
830
- }
831
- }
832
- }
833
- }
834
-
835
- private onDependencyResolved: DependencyResolverCallback = (request, result, error) => {
836
- // When a dependency is resolved, store its handle and peer-dependencies
837
- // in the state. This state should be persisted by the client so that the next
838
- // time it doesn't need to be resolved again.
839
- this.setState(({ dependencies, sdkVersion, wantedDependencyVersions }) => {
840
- const newDependencies = State.addObject(dependencies, request.name, {
841
- ...dependencies[request.name],
842
- version: request.version,
843
- ...(result
844
- ? {
845
- handle: result.handle,
846
- peerDependencies: result.dependencies,
847
- }
848
- : {}),
849
- ...(error ? { error } : {}),
850
- });
851
- return newDependencies !== dependencies
852
- ? {
853
- dependencies: newDependencies,
854
- missingDependencies: getMissingDependencies(
855
- newDependencies,
856
- sdkVersion,
857
- wantedDependencyVersions
858
- ),
859
- }
860
- : null;
861
- });
862
- };
863
-
864
- //
865
- // Online
866
- //
867
-
868
- /**
869
- * Enables or disables the Snack.
870
- *
871
- * When disabled, no uploads or dependency resolve operations
872
- * are performed.
873
- */
874
- setDisabled(disabled: boolean) {
875
- return this.setState((state) => (disabled !== state.disabled ? { disabled } : null));
876
- }
877
-
878
- /**
879
- * Makes the Snack available online.
880
- *
881
- * When online, a pubnub channel is created to which clients can
882
- * connect.
883
- */
884
- setOnline(enabled: boolean) {
885
- return this.setState((state) => {
886
- if (enabled && !state.transports['pubnub']) {
887
- return {
888
- transports: State.addObject(
889
- state.transports,
890
- 'pubnub',
891
- this.createTransport({
892
- name: 'pubnub',
893
- apiURL: this.apiURL,
894
- channel: state.channel,
895
- verbose: !!this.logger,
896
- })
897
- ),
898
- };
899
- } else if (!enabled && state.transports['pubnub']) {
900
- let connectedClients = state.connectedClients;
901
- for (const key in state.connectedClients) {
902
- if (state.connectedClients[key].transport === 'pubnub') {
903
- connectedClients = State.removeObject(connectedClients, key);
904
- }
905
- }
906
- return {
907
- transports: State.removeObject(state.transports, 'pubnub'),
908
- connectedClients,
909
- };
910
- } else {
911
- return null;
912
- }
913
- });
914
- }
915
-
916
- private updateDerivedOnlineState(state: SnackState, prevState: SnackState) {
917
- const { transports, sdkVersion, channel, id, name, disabled, savedSDKVersion } = state;
918
- if (
919
- transports !== prevState.transports ||
920
- sdkVersion !== prevState.sdkVersion ||
921
- channel !== prevState.channel ||
922
- id !== prevState.id ||
923
- name !== prevState.name ||
924
- savedSDKVersion !== prevState.savedSDKVersion
925
- ) {
926
- state.online = !!transports['pubnub'] && !disabled;
927
- state.url = createURL(
928
- this.host,
929
- sdkVersion,
930
- channel,
931
- savedSDKVersion && savedSDKVersion !== sdkVersion ? undefined : id
932
- );
933
- state.onlineName = `${name || 'Unnamed Snack'}`;
934
- }
935
- }
936
-
937
- private updateDerivedWebPreviewState(state: SnackState, prevState: SnackState) {
938
- const { transports, sdkVersion, url } = state;
939
- if ((url && !prevState.url) || sdkVersion !== prevState.sdkVersion) {
940
- state.webPreviewURL = transports['webplayer']
941
- ? getWebPlayerIFrameURL(this.webPlayerURL, sdkVersion, url, !!this.logger)
942
- : undefined;
943
- }
944
- }
945
-
946
- private onDevSessionSendBeaconCloseRequest = (sendBeaconCloseRequest: SnackSendBeaconRequest) => {
947
- this.setState((_state) => ({
948
- sendBeaconCloseRequest,
949
- }));
950
- };
951
-
952
- //
953
- // Transports
954
- //
955
-
956
- /**
957
- * Reloads all connected clients.
958
- *
959
- * Note: During the reload proces, clients may get disconnected which
960
- * causes the connectedClient to disappear and re-appear. The `reloadTimeout`
961
- * option in the constructor can be used to keep connectedClients "alive"
962
- * during the reload process.
963
- */
964
- reloadConnectedClients() {
965
- const connectedTransports = new Set<SnackTransport>();
966
- this.setState((state) => {
967
- let { connectedClients } = state;
968
- for (const key in state.connectedClients) {
969
- const connectedClient = state.connectedClients[key];
970
- connectedTransports.add(state.transports[connectedClient.transport]);
971
- connectedClients = State.addObject(connectedClients, key, {
972
- ...connectedClient,
973
- status: 'reloading',
974
- });
975
- }
976
- return connectedClients !== state.connectedClients ? { connectedClients } : null;
977
- });
978
- const reloadMessage: ProtocolReloadMessage = {
979
- type: 'RELOAD_SNACK',
980
- };
981
- if (connectedTransports.size) {
982
- this.logger?.comm('Reloading...');
983
- connectedTransports.forEach((transport) => {
984
- transport.postMessage({
985
- type: 'protocol_message',
986
- data: reloadMessage,
987
- });
988
- });
989
- }
990
- }
991
-
992
- /**
993
- * Requests a preview from the connected clients.
994
- *
995
- * The previews are returned in the `previewURL` field of each connectedClient.
996
- */
997
- getPreviewAsync(): Promise<SnackConnectedClients> {
998
- const { connectedClients, transports } = this.state;
999
- const connectedTransports = new Set<SnackTransport>();
1000
- Object.values(connectedClients).forEach(({ transport }) =>
1001
- connectedTransports.add(transports[transport])
1002
- );
1003
- if (!connectedTransports.size) {
1004
- return Promise.resolve(connectedClients);
1005
- }
1006
-
1007
- // Send status request to all transports that have
1008
- // active connectedClients.
1009
- const requestStatusMessage: ProtocolRequestStatusMessage = {
1010
- type: 'REQUEST_STATUS',
1011
- };
1012
- if (connectedTransports.size) {
1013
- this.logger?.comm('Requesting preview...');
1014
- connectedTransports.forEach((transport) => {
1015
- transport.postMessage({
1016
- type: 'protocol_message',
1017
- data: requestStatusMessage,
1018
- });
1019
- });
1020
- }
1021
-
1022
- // Wait for all status-reports to be received and
1023
- // return the connectedClients state when done.
1024
- // Or timeout when it takes too long...
1025
- return new Promise<SnackConnectedClients>((resolve, reject) => {
1026
- let timeoutTimer: any;
1027
- const completedConnections = new Set<string>();
1028
- const unsubscribe = this.addStateListener((state, prevState) => {
1029
- if (state.connectedClients !== prevState.connectedClients) {
1030
- for (const key in connectedClients) {
1031
- if (
1032
- connectedClients[key].previewTimestamp !==
1033
- state.connectedClients[key]?.previewTimestamp ||
1034
- !state.connectedClients[key]
1035
- ) {
1036
- completedConnections.add(key);
1037
- if (completedConnections.size === Object.values(connectedClients).length) {
1038
- unsubscribe();
1039
- clearTimeout(timeoutTimer);
1040
- resolve(state.connectedClients);
1041
- return;
1042
- }
1043
- }
1044
- }
1045
- }
1046
- });
1047
-
1048
- timeoutTimer = setTimeout(() => {
1049
- unsubscribe();
1050
- reject(new Error('Operation timed out'));
1051
- }, this.previewTimeout);
1052
- });
1053
- }
1054
-
1055
- private updateTransports(state: SnackState, prevState: SnackState) {
1056
- const transports = state.transports;
1057
- const prevTransports = prevState.transports;
1058
-
1059
- // Stop any any removed transports
1060
- if (!prevState.disabled && (transports !== prevTransports || state.disabled)) {
1061
- for (const id in prevTransports) {
1062
- if (
1063
- this.transportListeners[id] &&
1064
- (transports[id] !== prevTransports[id] || state.disabled)
1065
- ) {
1066
- prevTransports[id].removeEventListener('message', this.transportListeners[id]);
1067
- delete this.transportListeners[id];
1068
- prevTransports[id].postMessage({ type: 'stop' });
1069
- }
1070
- }
1071
- }
1072
-
1073
- // Start any added transports
1074
- if (!state.disabled && (transports !== prevTransports || prevState.disabled)) {
1075
- for (const id in transports) {
1076
- if (
1077
- !this.transportListeners[id] &&
1078
- (transports[id] !== prevTransports[id] || prevState.disabled)
1079
- ) {
1080
- this.transportListeners[id] = (event: any) => this.onTransportEvent(id, event);
1081
- transports[id].addEventListener('message', this.transportListeners[id]);
1082
- transports[id].postMessage({ type: 'start' });
1083
- }
1084
- }
1085
- }
1086
-
1087
- // Update the code
1088
- if (
1089
- !state.disabled &&
1090
- !State.isBusy(state) &&
1091
- (transports !== prevTransports || State.isCodeChanged(state, prevState) || prevState.disabled)
1092
- ) {
1093
- this._sendCodeChangesDebounced(
1094
- state,
1095
- prevTransports !== transports || (!State.isBusy(state) && State.isBusy(prevState))
1096
- );
1097
- }
1098
- }
1099
-
1100
- private onTransportEvent = (transport: string, event: SnackTransportEvent) => {
1101
- const { type, data } = event;
1102
- // @ts-ignore
1103
- const { connectionId } = event;
1104
- switch (type) {
1105
- case 'connect':
1106
- this.logger?.comm(`Client connected (${transport})`, connectionId);
1107
- this.onClientConnected(transport, connectionId, data);
1108
- break;
1109
- case 'disconnect':
1110
- this.logger?.comm(`Client disconnected (${transport})`, connectionId, data);
1111
- this.onClientDisconnected(transport, connectionId, data);
1112
- break;
1113
- case 'protocol_message':
1114
- this.logger?.comm_recv(`Message received (${transport})`, connectionId, data);
1115
- this.onProtocolMessageReceived(transport, connectionId, event.data);
1116
- break;
1117
- case 'send_message':
1118
- this.onProtocolMessageSent(transport, event.data);
1119
- break;
1120
- }
1121
- };
1122
-
1123
- private onClientConnected(transport: string, connectedClientId: string, data: any) {
1124
- this.setState((state) => {
1125
- return {
1126
- connectedClients: State.addObject(state.connectedClients, connectedClientId, {
1127
- transport,
1128
- id: data.id,
1129
- name: data.name,
1130
- platform: data.platform,
1131
- status: 'ok',
1132
- }),
1133
- };
1134
- });
1135
- }
1136
-
1137
- private onClientDisconnected(_transport: string, connectedClientId: string, _data: any) {
1138
- this.setState((state) => {
1139
- const connectedClient = state.connectedClients[connectedClientId];
1140
-
1141
- // When the connectedClient is reloading, schedule a cleanup
1142
- // in case the connectedClient does not return
1143
- if (connectedClient?.status === 'reloading' && this.reloadTimeout >= 0) {
1144
- if (this.pruneConnectionsTimer) {
1145
- clearTimeout(this.pruneConnectionsTimer);
1146
- this.pruneConnectionsTimer = undefined;
1147
- }
1148
- this.pruneConnectionsTimer = setTimeout(() => {
1149
- this.pruneConnectionsTimer = undefined;
1150
- this.setState((state) => {
1151
- let connectedClients = state.connectedClients;
1152
- for (const key in state.connectedClients) {
1153
- if (state.connectedClients[key].status === 'reloading') {
1154
- connectedClients = State.removeObject(connectedClients, key);
1155
- }
1156
- }
1157
- return connectedClients !== state.connectedClients ? { connectedClients } : null;
1158
- });
1159
- }, this.reloadTimeout);
1160
- return null;
1161
- } else {
1162
- // Otherwise, remove the connectedClient immediately
1163
- const connectedClients = State.removeObject(state.connectedClients, connectedClientId);
1164
- return connectedClients !== state.connectedClients ? { connectedClients } : null;
1165
- }
1166
- });
1167
- }
1168
-
1169
- //
1170
- // Messaging
1171
- //
1172
-
1173
- /**
1174
- * Adds a callback for listening for any client generated log messages.
1175
- *
1176
- * @example
1177
- * ```
1178
- * const unsubscribe = Snack.addLogListener((log) => {
1179
- * console.log('log message received: ', log);
1180
- * });
1181
- *
1182
- * unsubscribe(); // Remove listener
1183
- * ```
1184
- */
1185
- addLogListener(listener: SnackLogListener): SnackListenerSubscription {
1186
- this.logListeners.add(listener);
1187
- return () => this.logListeners.delete(listener);
1188
- }
1189
-
1190
- private onProtocolMessageReceived(
1191
- transport: string,
1192
- connectedClientId: string,
1193
- message: ProtocolIncomingMessage
1194
- ) {
1195
- // Ignore messages from clients that are not setup yet or have disconnected
1196
- if (!this.state.connectedClients[connectedClientId]) {
1197
- return;
1198
- }
1199
-
1200
- switch (message.type) {
1201
- case 'CONSOLE':
1202
- this.onConsoleMessageReceived(connectedClientId, message);
1203
- break;
1204
- case 'ERROR':
1205
- this.onErrorMessageReceived(connectedClientId, message);
1206
- break;
1207
- case 'STATUS_REPORT':
1208
- this.onStatusReportMessageReceived(connectedClientId, message);
1209
- break;
1210
- // @ts-ignore: CODE is echoed by pubnub, we ignore it
1211
- case 'CODE':
1212
- break;
1213
- // @ts-ignore: RELOAD_SNACK is echoed by pubnub, we ignore it
1214
- case 'RELOAD_SNACK':
1215
- break;
1216
- // @ts-ignore: REQUEST_STATUS is echoed by pubnub, we ignore it
1217
- case 'REQUEST_STATUS':
1218
- break;
1219
- default:
1220
- this.logger?.error('Invalid message received', transport, message);
1221
- break;
1222
- }
1223
- }
1224
-
1225
- private onProtocolMessageSent(transport: string, message: ProtocolOutgoingMessage) {
1226
- switch (message.type) {
1227
- case 'CODE':
1228
- this.setState((state) => {
1229
- let { connectedClients } = state;
1230
- for (const connectedClientId in connectedClients) {
1231
- const connectedClient = connectedClients[connectedClientId];
1232
- if (connectedClient.transport === transport) {
1233
- connectedClients = State.addObject(connectedClients, connectedClientId, {
1234
- ...connectedClient,
1235
- error: undefined,
1236
- status: connectedClient.status === 'error' ? 'ok' : connectedClient.status,
1237
- });
1238
- }
1239
- }
1240
- return connectedClients !== state.connectedClients ? { connectedClients } : null;
1241
- });
1242
- break;
1243
- }
1244
- }
1245
-
1246
- private onConsoleMessageReceived(connectedClientId: string, message: ProtocolConsoleMessage) {
1247
- const payload = message.payload || [];
1248
-
1249
- const event: SnackLogEvent = {
1250
- type: message.method,
1251
- connectedClient: this.state.connectedClients[connectedClientId],
1252
- message: payload.join(' '),
1253
- // error?
1254
- // arguments: payload,
1255
- };
1256
-
1257
- this.logListeners.forEach((listener) => listener(event));
1258
- }
1259
-
1260
- private onErrorMessageReceived(connectedClientId: string, message: ProtocolErrorMessage) {
1261
- try {
1262
- const json = JSON.parse(message.error);
1263
- const error = createError({
1264
- name: json.name || 'Error',
1265
- message: json.message || '',
1266
- fileName: json.fileName,
1267
- lineNumber: json.lineNumber || json.loc?.line || json.line,
1268
- columnNumber: json.columnNumber || json.loc?.column || json.column,
1269
- stack: json.stack,
1270
- });
1271
- this.setState((state) => ({
1272
- connectedClients: State.addObject(state.connectedClients, connectedClientId, {
1273
- ...state.connectedClients[connectedClientId],
1274
- error,
1275
- status: 'error',
1276
- }),
1277
- }));
1278
- } catch (e) {
1279
- this.logger?.error('Failed to parse received error message', message);
1280
- }
1281
- }
1282
-
1283
- private onStatusReportMessageReceived(connectedClientId: string, message: ProtocolStatusMessage) {
1284
- const { previewLocation } = message;
1285
- this.setState((state) => ({
1286
- connectedClients: State.addObject(state.connectedClients, connectedClientId, {
1287
- ...state.connectedClients[connectedClientId],
1288
- previewURL: previewLocation,
1289
- previewTimestamp: Date.now(),
1290
- }),
1291
- }));
1292
- }
1293
- }