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