@kubohiroya/turbowarp-plus-editor-project-folder 0.8.0 → 0.9.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/THIRD_PARTY_NOTICES.md +716 -0
- package/dist/create-folder.d.ts +8 -0
- package/dist/explorer-files.d.ts +23 -0
- package/dist/explorer-menu.d.ts +53 -0
- package/dist/explorer.d.ts +34 -4
- package/dist/explorer.js +2020 -694
- package/dist/file-preview.d.ts +24 -0
- package/dist/folder-registry.d.ts +4 -0
- package/dist/index.d.ts +10 -0
- package/dist/index.js +1019 -555
- package/dist/session.d.ts +6 -0
- package/dist/shared-JdaDvk2R.js +588 -0
- package/dist/shared-kI7qYraF.js +30130 -0
- package/dist/text-file-editor.d.ts +17 -0
- package/package.json +16 -1
- package/src/create-folder.ts +99 -0
- package/src/explorer-files.ts +197 -0
- package/src/explorer-menu.tsx +135 -0
- package/src/explorer.tsx +388 -22
- package/src/file-preview.ts +134 -0
- package/src/folder-registry.ts +5 -0
- package/src/index.ts +27 -2
- package/src/session.ts +77 -12
- package/src/source.ts +16 -8
- package/src/text-file-editor.ts +356 -0
- package/vite.config.ts +2 -0
- package/dist/shared-DlmcdO1_.js +0 -458
package/dist/session.d.ts
CHANGED
|
@@ -35,6 +35,7 @@ export interface FolderHost {
|
|
|
35
35
|
beforeLoad(): void;
|
|
36
36
|
onOpened(title: string): void;
|
|
37
37
|
onSaved(): void;
|
|
38
|
+
saveWithLock?<T>(save: () => Promise<T>): Promise<T>;
|
|
38
39
|
blockReload?: {
|
|
39
40
|
isRunning(): boolean;
|
|
40
41
|
subscribe(listener: () => void): () => void;
|
|
@@ -90,6 +91,9 @@ export declare function createFolderSession(vm: FolderVM, host: FolderHost): {
|
|
|
90
91
|
detach(): void;
|
|
91
92
|
/** Calls `listener` when a folder opens or closes, and after a save. Returns the function that stops it. */
|
|
92
93
|
subscribe(listener: () => void): () => void;
|
|
94
|
+
subscribeEdits(listener: () => void): () => void;
|
|
95
|
+
/** Files affected by the pending save. A save in progress still owns its baseline. */
|
|
96
|
+
unsavedPaths(): ReadonlySet<string> | null;
|
|
93
97
|
readonly canSave: boolean;
|
|
94
98
|
readonly busy: boolean;
|
|
95
99
|
readonly reloadState: ReloadState;
|
|
@@ -101,6 +105,7 @@ export declare function createFolderSession(vm: FolderVM, host: FolderHost): {
|
|
|
101
105
|
/** Identifies the pending project file version, so a host can attempt an automatic apply only once. */
|
|
102
106
|
readonly pendingVersion: string | null;
|
|
103
107
|
readonly directory: FileSystemDirectoryHandle | null;
|
|
108
|
+
mutate(directory: FileSystemDirectoryHandle, operation: (guard: () => void) => Promise<void>): Promise<void>;
|
|
104
109
|
/**
|
|
105
110
|
* Reads what to compare before unsaved edits are replaced. `editor` is `null` when the edits cannot be
|
|
106
111
|
* written to the folder, and `disk` when the folder's project file cannot be read.
|
|
@@ -115,6 +120,7 @@ export declare function createFolderSession(vm: FolderVM, host: FolderHost): {
|
|
|
115
120
|
reloadAll(confirmReplace: () => boolean): Promise<OpenResult>;
|
|
116
121
|
open(pick: FileSystemPicker, confirmReplace: () => boolean): Promise<OpenResult>;
|
|
117
122
|
openDirectory(directory: FileSystemDirectoryHandle, confirmReplace: () => boolean): Promise<OpenResult>;
|
|
123
|
+
createFromSnapshot(getDirectory: () => Promise<FileSystemDirectoryHandle | null>, prepareFiles: () => Promise<ReadonlyMap<string, Uint8Array>>, isCurrent: () => boolean): Promise<OpenResult>;
|
|
118
124
|
save(): Promise<SaveResult>;
|
|
119
125
|
dispose: () => void;
|
|
120
126
|
};
|
|
@@ -0,0 +1,588 @@
|
|
|
1
|
+
// \0@oxc-project+runtime@0.156.0/helpers/esm/asyncIterator.js
|
|
2
|
+
function _asyncIterator(r) {
|
|
3
|
+
var n, t, o, e = 2;
|
|
4
|
+
for ("undefined" != typeof Symbol && (t = Symbol.asyncIterator, o = Symbol.iterator); e--;) {
|
|
5
|
+
if (t && null != (n = r[t])) return n.call(r);
|
|
6
|
+
if (o && null != (n = r[o])) return new AsyncFromSyncIterator(n.call(r));
|
|
7
|
+
t = "@@asyncIterator", o = "@@iterator";
|
|
8
|
+
}
|
|
9
|
+
throw new TypeError("Object is not async iterable");
|
|
10
|
+
}
|
|
11
|
+
function AsyncFromSyncIterator(r) {
|
|
12
|
+
function AsyncFromSyncIteratorContinuation(r) {
|
|
13
|
+
if (Object(r) !== r) return Promise.reject(/* @__PURE__ */ new TypeError(r + " is not an object."));
|
|
14
|
+
var n = r.done;
|
|
15
|
+
return Promise.resolve(r.value).then(function(r) {
|
|
16
|
+
return {
|
|
17
|
+
value: r,
|
|
18
|
+
done: n
|
|
19
|
+
};
|
|
20
|
+
});
|
|
21
|
+
}
|
|
22
|
+
return AsyncFromSyncIterator = function AsyncFromSyncIterator(r) {
|
|
23
|
+
this.s = r, this.n = r.next;
|
|
24
|
+
}, AsyncFromSyncIterator.prototype = {
|
|
25
|
+
s: null,
|
|
26
|
+
n: null,
|
|
27
|
+
next: function next() {
|
|
28
|
+
return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments));
|
|
29
|
+
},
|
|
30
|
+
"return": function _return(r) {
|
|
31
|
+
var n = this.s["return"];
|
|
32
|
+
return void 0 === n ? Promise.resolve({
|
|
33
|
+
value: r,
|
|
34
|
+
done: !0
|
|
35
|
+
}) : AsyncFromSyncIteratorContinuation(n.apply(this.s, arguments));
|
|
36
|
+
},
|
|
37
|
+
"throw": function _throw(r) {
|
|
38
|
+
var n = this.s["throw"];
|
|
39
|
+
return void 0 === n ? Promise.reject(r) : AsyncFromSyncIteratorContinuation(n.apply(this.s, arguments));
|
|
40
|
+
}
|
|
41
|
+
}, new AsyncFromSyncIterator(r);
|
|
42
|
+
}
|
|
43
|
+
// \0@oxc-project+runtime@0.156.0/helpers/esm/typeof.js
|
|
44
|
+
function _typeof(o) {
|
|
45
|
+
"@babel/helpers - typeof";
|
|
46
|
+
return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
|
|
47
|
+
return typeof o;
|
|
48
|
+
} : function(o) {
|
|
49
|
+
return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
|
|
50
|
+
}, _typeof(o);
|
|
51
|
+
}
|
|
52
|
+
// \0@oxc-project+runtime@0.156.0/helpers/esm/toPrimitive.js
|
|
53
|
+
function toPrimitive(t, r) {
|
|
54
|
+
if ("object" != _typeof(t) || !t) return t;
|
|
55
|
+
var e = t[Symbol.toPrimitive];
|
|
56
|
+
if (void 0 !== e) {
|
|
57
|
+
var i = e.call(t, r || "default");
|
|
58
|
+
if ("object" != _typeof(i)) return i;
|
|
59
|
+
throw new TypeError("@@toPrimitive must return a primitive value.");
|
|
60
|
+
}
|
|
61
|
+
return ("string" === r ? String : Number)(t);
|
|
62
|
+
}
|
|
63
|
+
// \0@oxc-project+runtime@0.156.0/helpers/esm/toPropertyKey.js
|
|
64
|
+
function toPropertyKey(t) {
|
|
65
|
+
var i = toPrimitive(t, "string");
|
|
66
|
+
return "symbol" == _typeof(i) ? i : i + "";
|
|
67
|
+
}
|
|
68
|
+
// \0@oxc-project+runtime@0.156.0/helpers/esm/defineProperty.js
|
|
69
|
+
function _defineProperty(e, r, t) {
|
|
70
|
+
return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
|
|
71
|
+
value: t,
|
|
72
|
+
enumerable: !0,
|
|
73
|
+
configurable: !0,
|
|
74
|
+
writable: !0
|
|
75
|
+
}) : e[r] = t, e;
|
|
76
|
+
}
|
|
77
|
+
// \0@oxc-project+runtime@0.156.0/helpers/esm/objectSpread2.js
|
|
78
|
+
function ownKeys(e, r) {
|
|
79
|
+
var t = Object.keys(e);
|
|
80
|
+
if (Object.getOwnPropertySymbols) {
|
|
81
|
+
var o = Object.getOwnPropertySymbols(e);
|
|
82
|
+
r && (o = o.filter(function(r) {
|
|
83
|
+
return Object.getOwnPropertyDescriptor(e, r).enumerable;
|
|
84
|
+
})), t.push.apply(t, o);
|
|
85
|
+
}
|
|
86
|
+
return t;
|
|
87
|
+
}
|
|
88
|
+
function _objectSpread2(e) {
|
|
89
|
+
for (var r = 1; r < arguments.length; r++) {
|
|
90
|
+
var t = null != arguments[r] ? arguments[r] : {};
|
|
91
|
+
r % 2 ? ownKeys(Object(t), !0).forEach(function(r) {
|
|
92
|
+
_defineProperty(e, r, t[r]);
|
|
93
|
+
}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r) {
|
|
94
|
+
Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
|
|
95
|
+
});
|
|
96
|
+
}
|
|
97
|
+
return e;
|
|
98
|
+
}
|
|
99
|
+
// \0@oxc-project+runtime@0.156.0/helpers/esm/objectWithoutPropertiesLoose.js
|
|
100
|
+
function _objectWithoutPropertiesLoose(r, e) {
|
|
101
|
+
if (null == r) return {};
|
|
102
|
+
var t = {};
|
|
103
|
+
for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
|
|
104
|
+
if (e.includes(n)) continue;
|
|
105
|
+
t[n] = r[n];
|
|
106
|
+
}
|
|
107
|
+
return t;
|
|
108
|
+
}
|
|
109
|
+
// \0@oxc-project+runtime@0.156.0/helpers/esm/objectWithoutProperties.js
|
|
110
|
+
function _objectWithoutProperties(e, t) {
|
|
111
|
+
if (null == e) return {};
|
|
112
|
+
var o, r, i = _objectWithoutPropertiesLoose(e, t);
|
|
113
|
+
if (Object.getOwnPropertySymbols) {
|
|
114
|
+
var s = Object.getOwnPropertySymbols(e);
|
|
115
|
+
for (r = 0; r < s.length; r++) o = s[r], t.includes(o) || {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
|
|
116
|
+
}
|
|
117
|
+
return i;
|
|
118
|
+
}
|
|
119
|
+
// src/source.ts
|
|
120
|
+
var _excluded = ["targets"];
|
|
121
|
+
var _excluded2 = ["targets"];
|
|
122
|
+
var _excluded3 = ["targets"];
|
|
123
|
+
var projectFile = "project.source.json";
|
|
124
|
+
var manifestFile = "sb3-source.json";
|
|
125
|
+
var extensionsFile = "embedded-extensions.json";
|
|
126
|
+
var embeddedReference = "embedded-extension:";
|
|
127
|
+
var FolderError = class extends Error {
|
|
128
|
+
constructor(code, detail) {
|
|
129
|
+
super(detail !== null && detail !== void 0 ? detail : code);
|
|
130
|
+
this.code = code;
|
|
131
|
+
}
|
|
132
|
+
};
|
|
133
|
+
var unsupported = (detail) => {
|
|
134
|
+
throw new FolderError("unsupported", detail);
|
|
135
|
+
};
|
|
136
|
+
var isObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
|
|
137
|
+
var readObject = (text) => {
|
|
138
|
+
const value = JSON.parse(text);
|
|
139
|
+
if (!isObject(value)) return unsupported("Expected a JSON object");
|
|
140
|
+
return value;
|
|
141
|
+
};
|
|
142
|
+
var targetKey = (target) => target.isStage ? "stage" : `sprite:${target.name}`;
|
|
143
|
+
function parseProject(text) {
|
|
144
|
+
const project = readObject(text);
|
|
145
|
+
if (!Array.isArray(project.targets)) return unsupported("Missing targets");
|
|
146
|
+
const keys = /* @__PURE__ */ new Set();
|
|
147
|
+
let stages = 0;
|
|
148
|
+
for (const target of project.targets) {
|
|
149
|
+
if (!isObject(target) || typeof target.isStage !== "boolean" || typeof target.name !== "string") return unsupported("Invalid target");
|
|
150
|
+
const key = targetKey(target);
|
|
151
|
+
if (keys.has(key)) return unsupported("Ambiguous target names");
|
|
152
|
+
keys.add(key);
|
|
153
|
+
if (target.isStage) stages++;
|
|
154
|
+
if (target.blocks !== void 0 && !isObject(target.blocks)) return unsupported("Invalid blocks");
|
|
155
|
+
if (target.comments !== void 0 && !isObject(target.comments)) return unsupported("Invalid comments");
|
|
156
|
+
}
|
|
157
|
+
if (stages !== 1) return unsupported("Expected one stage");
|
|
158
|
+
return project;
|
|
159
|
+
}
|
|
160
|
+
var getFile = async (dir, name) => dir ? (await dir.getFileHandle(name)).getFile() : unsupported(`Missing folder for ${name}`);
|
|
161
|
+
var fileVersion = (file) => `${file.size}:${file.lastModified}`;
|
|
162
|
+
var fileBytes = async (file) => new Uint8Array(await file.arrayBuffer());
|
|
163
|
+
var readBytes = async (dir, name) => fileBytes(await getFile(dir, name));
|
|
164
|
+
var readNames = async (dir) => {
|
|
165
|
+
const names = /* @__PURE__ */ new Set();
|
|
166
|
+
if (!dir) return names;
|
|
167
|
+
var _iteratorAbruptCompletion = false;
|
|
168
|
+
var _didIteratorError = false;
|
|
169
|
+
var _iteratorError;
|
|
170
|
+
try {
|
|
171
|
+
for (var _iterator = _asyncIterator(dir.values()), _step; _iteratorAbruptCompletion = !(_step = await _iterator.next()).done; _iteratorAbruptCompletion = false) {
|
|
172
|
+
const entry = _step.value;
|
|
173
|
+
if (entry.kind !== "file") return unsupported("Nested entries are outside the supported source format");
|
|
174
|
+
names.add(entry.name);
|
|
175
|
+
}
|
|
176
|
+
} catch (err) {
|
|
177
|
+
_didIteratorError = true;
|
|
178
|
+
_iteratorError = err;
|
|
179
|
+
} finally {
|
|
180
|
+
try {
|
|
181
|
+
if (_iteratorAbruptCompletion && _iterator.return != null) await _iterator.return();
|
|
182
|
+
} finally {
|
|
183
|
+
if (_didIteratorError) throw _iteratorError;
|
|
184
|
+
}
|
|
185
|
+
}
|
|
186
|
+
return names;
|
|
187
|
+
};
|
|
188
|
+
var readDirectory = (dir, name) => dir.getDirectoryHandle(name).catch((error) => {
|
|
189
|
+
if (error instanceof DOMException && error.name === "NotFoundError") return null;
|
|
190
|
+
throw error;
|
|
191
|
+
});
|
|
192
|
+
var sameNames = (actual, expected) => {
|
|
193
|
+
const expectedNames = new Set(expected);
|
|
194
|
+
return actual.size === expectedNames.size && [...actual].every((name) => expectedNames.has(name));
|
|
195
|
+
};
|
|
196
|
+
var assetTypeFor = (storage, kind, format) => {
|
|
197
|
+
var _storage$AssetType$Fo;
|
|
198
|
+
if (kind === "fonts") return (_storage$AssetType$Fo = storage.AssetType.Font) !== null && _storage$AssetType$Fo !== void 0 ? _storage$AssetType$Fo : unsupported("The editor does not support font assets");
|
|
199
|
+
if (kind === "sounds") return storage.AssetType.Sound;
|
|
200
|
+
return format === "svg" ? storage.AssetType.ImageVector : storage.AssetType.ImageBitmap;
|
|
201
|
+
};
|
|
202
|
+
var assetKey = (type, id, format) => `${type.name}/${id}.${format}`;
|
|
203
|
+
var extensionPath = (id) => {
|
|
204
|
+
if (!/^[A-Za-z0-9._-]+$/u.test(id)) return unsupported(`Embedded extension ID cannot be used as a filename: ${id}`);
|
|
205
|
+
return `extensions/${id}.js`;
|
|
206
|
+
};
|
|
207
|
+
var validUrlPart = (part) => typeof part === "string" && part.length > 0 && !/[;,\r\n]/u.test(part);
|
|
208
|
+
var extensionURLs = (project) => {
|
|
209
|
+
const urls = project.extensionURLs === void 0 ? {} : project.extensionURLs;
|
|
210
|
+
if (!isObject(urls) || Object.values(urls).some((url) => typeof url !== "string")) return unsupported("Invalid extensionURLs");
|
|
211
|
+
return urls;
|
|
212
|
+
};
|
|
213
|
+
var apiManifestName = (entry) => {
|
|
214
|
+
if (entry.source === void 0) return;
|
|
215
|
+
if (!isObject(entry.source)) return unsupported(`Invalid source for embedded extension: ${entry.id}`);
|
|
216
|
+
const api = entry.source.apiManifest;
|
|
217
|
+
if (api === void 0) return;
|
|
218
|
+
const name = `${entry.id}.manifest.json`;
|
|
219
|
+
if (!isObject(api) || api.path !== `extensions/${name}`) return unsupported(`Invalid API manifest path: ${entry.id}`);
|
|
220
|
+
return name;
|
|
221
|
+
};
|
|
222
|
+
var extensionNames = (entries) => entries.flatMap((entry) => {
|
|
223
|
+
const script = `${entry.id}.js`;
|
|
224
|
+
const api = apiManifestName(entry);
|
|
225
|
+
return api === void 0 ? [script] : [script, api];
|
|
226
|
+
});
|
|
227
|
+
function validateExtensions(project, value) {
|
|
228
|
+
if (value.formatVersion !== 1 || !Array.isArray(value.extensions)) return unsupported("Invalid embedded extension manifest");
|
|
229
|
+
const urls = extensionURLs(project);
|
|
230
|
+
const ids = /* @__PURE__ */ new Set();
|
|
231
|
+
for (const entry of value.extensions) {
|
|
232
|
+
if (!isObject(entry) || typeof entry.id !== "string" || ids.has(entry.id) || entry.path !== extensionPath(entry.id) || !validUrlPart(entry.mediaType) || !Array.isArray(entry.parameters) || !entry.parameters.every(validUrlPart) || entry.encoding !== "base64" && entry.encoding !== "percent" || !Object.hasOwn(urls, entry.id) || urls[entry.id] !== embeddedReference + entry.path) return unsupported("Invalid embedded extension entry or project reference");
|
|
233
|
+
ids.add(entry.id);
|
|
234
|
+
}
|
|
235
|
+
for (const [id, url] of Object.entries(urls)) if (url.startsWith("data:") || url.startsWith(embeddedReference) && !ids.has(id)) return unsupported(`Invalid embedded extension reference: ${id}`);
|
|
236
|
+
if (value.extensionBundles !== void 0) {
|
|
237
|
+
if (!Array.isArray(value.extensionBundles)) return unsupported("Invalid extensionBundles");
|
|
238
|
+
const bundleIds = /* @__PURE__ */ new Set();
|
|
239
|
+
const members = /* @__PURE__ */ new Set();
|
|
240
|
+
for (const bundle of value.extensionBundles) {
|
|
241
|
+
if (!isObject(bundle) || typeof bundle.id !== "string" || !/^[a-z0-9]+$/u.test(bundle.id) || ids.has(bundle.id) || bundleIds.has(bundle.id) || typeof bundle.name !== "string" || !bundle.name.trim() || /[\r\n]/u.test(bundle.name) || !Array.isArray(bundle.members) || bundle.members.length < 2) return unsupported("Invalid extension bundle");
|
|
242
|
+
bundleIds.add(bundle.id);
|
|
243
|
+
for (const member of bundle.members) {
|
|
244
|
+
if (typeof member !== "string" || !/^[a-z0-9]+$/u.test(member) || !ids.has(member) || members.has(member)) return unsupported(`Invalid member of extension bundle: ${bundle.id}`);
|
|
245
|
+
members.add(member);
|
|
246
|
+
}
|
|
247
|
+
}
|
|
248
|
+
}
|
|
249
|
+
return value;
|
|
250
|
+
}
|
|
251
|
+
function encodeDataUrl(entry, bytes) {
|
|
252
|
+
const metadata = [entry.mediaType, ...entry.parameters].join(";");
|
|
253
|
+
if (entry.encoding === "percent") return `data:${metadata},${Array.from(bytes, (byte) => `%${byte.toString(16).padStart(2, "0").toUpperCase()}`).join("")}`;
|
|
254
|
+
let binary = "";
|
|
255
|
+
for (let offset = 0; offset < bytes.length; offset += 8192) binary += String.fromCharCode(...bytes.subarray(offset, offset + 8192));
|
|
256
|
+
return `data:${metadata};base64,${btoa(binary)}`;
|
|
257
|
+
}
|
|
258
|
+
function decodeDataUrl(id, url) {
|
|
259
|
+
const comma = url.indexOf(",");
|
|
260
|
+
if (comma === -1) return unsupported(`Invalid data URL for embedded extension: ${id}`);
|
|
261
|
+
const [type, ...parameters] = url.slice(5, comma).split(";");
|
|
262
|
+
const mediaType = type || "text/plain";
|
|
263
|
+
const base64 = parameters.indexOf("base64");
|
|
264
|
+
if (base64 !== -1) parameters.splice(base64, 1);
|
|
265
|
+
const encoding = base64 === -1 ? "percent" : "base64";
|
|
266
|
+
if (!validUrlPart(mediaType) || !parameters.every(validUrlPart) || parameters.includes("base64")) return unsupported(`Invalid data URL metadata for embedded extension: ${id}`);
|
|
267
|
+
const payload = url.slice(comma + 1);
|
|
268
|
+
try {
|
|
269
|
+
if (encoding === "percent") return {
|
|
270
|
+
metadata: {
|
|
271
|
+
mediaType,
|
|
272
|
+
parameters,
|
|
273
|
+
encoding
|
|
274
|
+
},
|
|
275
|
+
bytes: new TextEncoder().encode(decodeURIComponent(payload))
|
|
276
|
+
};
|
|
277
|
+
if (!/^[A-Za-z0-9+/]*={0,2}$/u.test(payload)) throw new Error("Invalid base64");
|
|
278
|
+
const binary = atob(payload.replace(/=+$/u, ""));
|
|
279
|
+
return {
|
|
280
|
+
metadata: {
|
|
281
|
+
mediaType,
|
|
282
|
+
parameters,
|
|
283
|
+
encoding
|
|
284
|
+
},
|
|
285
|
+
bytes: Uint8Array.from(binary, (char) => char.charCodeAt(0))
|
|
286
|
+
};
|
|
287
|
+
} catch (_unused) {
|
|
288
|
+
return unsupported(`Invalid data URL payload for embedded extension: ${id}`);
|
|
289
|
+
}
|
|
290
|
+
}
|
|
291
|
+
function hasSandboxedNoticeRequirement(bundle, entry, bytes) {
|
|
292
|
+
let requirement;
|
|
293
|
+
if (bundle.buildMode === "module") {
|
|
294
|
+
const source = entry.source;
|
|
295
|
+
if (isObject(source) && isObject(source.module)) requirement = source.module.unsandboxed;
|
|
296
|
+
} else {
|
|
297
|
+
var _exec;
|
|
298
|
+
const script = new TextDecoder().decode(bytes);
|
|
299
|
+
requirement = (_exec = /^\/\/ Unsandboxed: (.+)\r?$/mu.exec(script)) === null || _exec === void 0 ? void 0 : _exec[1].trim();
|
|
300
|
+
}
|
|
301
|
+
return requirement === "required" || requirement === "optional";
|
|
302
|
+
}
|
|
303
|
+
function planExtensionSave(source, project) {
|
|
304
|
+
const urls = _objectSpread2({}, extensionURLs(project));
|
|
305
|
+
const entries = new Map(source.embedded.extensions.map((entry) => [entry.id, entry]));
|
|
306
|
+
const writes = /* @__PURE__ */ new Map();
|
|
307
|
+
const sourceRemoved = [];
|
|
308
|
+
for (const [id, entry] of entries) if (!Object.hasOwn(urls, id) || !urls[id].startsWith("data:") && urls[id] !== embeddedReference + entry.path) entries.delete(id);
|
|
309
|
+
for (const [id, url] of Object.entries(urls)) {
|
|
310
|
+
if (!url.startsWith("data:")) continue;
|
|
311
|
+
const path = extensionPath(id);
|
|
312
|
+
const { metadata, bytes } = decodeDataUrl(id, url);
|
|
313
|
+
const name = `${id}.js`;
|
|
314
|
+
const previous = entries.get(id);
|
|
315
|
+
urls[id] = embeddedReference + path;
|
|
316
|
+
if (!previous || !sameBytes(source.extensionBytes.get(name), bytes)) {
|
|
317
|
+
const entry = _objectSpread2(_objectSpread2({}, previous), {}, {
|
|
318
|
+
id,
|
|
319
|
+
path
|
|
320
|
+
}, metadata);
|
|
321
|
+
if (entry.source !== void 0) {
|
|
322
|
+
delete entry.source;
|
|
323
|
+
sourceRemoved.push(id);
|
|
324
|
+
}
|
|
325
|
+
entries.set(id, entry);
|
|
326
|
+
writes.set(name, bytes);
|
|
327
|
+
}
|
|
328
|
+
}
|
|
329
|
+
const embedded = _objectSpread2(_objectSpread2({}, source.embedded), {}, { extensions: [...entries.values()] });
|
|
330
|
+
if (embedded.extensionBundles) embedded.extensionBundles = embedded.extensionBundles.flatMap((bundle) => {
|
|
331
|
+
const members = bundle.members.filter((id) => entries.has(id) && !(bundle.buildMode === "module" && sourceRemoved.includes(id)));
|
|
332
|
+
if (members.length < 2) return [];
|
|
333
|
+
const updated = _objectSpread2(_objectSpread2({}, bundle), {}, { members });
|
|
334
|
+
const changed = members.length !== bundle.members.length || members.some((id) => writes.has(`${id}.js`));
|
|
335
|
+
if (updated.sandboxedNotice !== void 0 && changed && !members.some((id) => {
|
|
336
|
+
var _writes$get;
|
|
337
|
+
const name = `${id}.js`;
|
|
338
|
+
return hasSandboxedNoticeRequirement(updated, entries.get(id), (_writes$get = writes.get(name)) !== null && _writes$get !== void 0 ? _writes$get : source.extensionBytes.get(name));
|
|
339
|
+
})) delete updated.sandboxedNotice;
|
|
340
|
+
return [updated];
|
|
341
|
+
});
|
|
342
|
+
const result = project.extensionURLs === void 0 ? project : _objectSpread2(_objectSpread2({}, project), {}, { extensionURLs: urls });
|
|
343
|
+
validateExtensions(result, embedded);
|
|
344
|
+
const names = new Set(extensionNames(embedded.extensions));
|
|
345
|
+
return {
|
|
346
|
+
project: result,
|
|
347
|
+
embedded,
|
|
348
|
+
manifestChanged: !equal(embedded, source.embedded),
|
|
349
|
+
writes,
|
|
350
|
+
sourceRemoved,
|
|
351
|
+
removed: [...source.extensionBytes.keys()].filter((name) => !names.has(name))
|
|
352
|
+
};
|
|
353
|
+
}
|
|
354
|
+
async function readFolder(directory, storage) {
|
|
355
|
+
const versions = /* @__PURE__ */ new Map();
|
|
356
|
+
const readEntry = async (dir, name, prefix = "") => {
|
|
357
|
+
const file = await getFile(dir, name);
|
|
358
|
+
versions.set(prefix + name, fileVersion(file));
|
|
359
|
+
return [name, await fileBytes(file)];
|
|
360
|
+
};
|
|
361
|
+
const filenames = [
|
|
362
|
+
projectFile,
|
|
363
|
+
manifestFile,
|
|
364
|
+
extensionsFile
|
|
365
|
+
];
|
|
366
|
+
const files = new Map(await Promise.all(filenames.map((name) => readEntry(directory, name))));
|
|
367
|
+
const decoder = new TextDecoder("utf-8", { fatal: true });
|
|
368
|
+
const projectText = decoder.decode(files.get(projectFile));
|
|
369
|
+
const project = parseProject(projectText);
|
|
370
|
+
const manifest = readObject(decoder.decode(files.get(manifestFile)));
|
|
371
|
+
const embedded = readObject(decoder.decode(files.get(extensionsFile)));
|
|
372
|
+
if (manifest.formatVersion !== 1 || manifest.project !== "project.source.json" || manifest.embeddedExtensions !== "embedded-extensions.json" || manifest.assetsDirectory !== "assets" || !Array.isArray(manifest.archiveEntries)) return unsupported("Expected an sb3-toolchain v1 folder");
|
|
373
|
+
if (project.turboWarpPlus !== void 0) return unsupported("Plus extension manifests are not supported in project folders");
|
|
374
|
+
const extensionManifest = validateExtensions(project, embedded);
|
|
375
|
+
const references = projectAssets(project);
|
|
376
|
+
const expected = /* @__PURE__ */ new Set(["project.json", ...references.keys()]);
|
|
377
|
+
if (manifest.archiveEntries.length !== expected.size || !sameNames(new Set(manifest.archiveEntries), expected)) return unsupported("Asset references and archiveEntries do not match");
|
|
378
|
+
expected.delete("project.json");
|
|
379
|
+
const [assets, extensions] = await Promise.all([readDirectory(directory, "assets"), readDirectory(directory, "extensions")]);
|
|
380
|
+
const scripts = extensionNames(extensionManifest.extensions);
|
|
381
|
+
if (!sameNames(await readNames(assets), expected) || !sameNames(await readNames(extensions), scripts)) return unsupported("Unexpected or missing source files");
|
|
382
|
+
const bytes = new Map(await Promise.all([...expected].map((name) => readEntry(assets, name, "assets/"))));
|
|
383
|
+
const extensionBytes = new Map(await Promise.all(scripts.map((name) => readEntry(extensions, name, "extensions/"))));
|
|
384
|
+
const loadText = extensionManifest.extensions.length ? JSON.stringify(_objectSpread2(_objectSpread2({}, project), {}, { extensionURLs: _objectSpread2(_objectSpread2({}, extensionURLs(project)), Object.fromEntries(extensionManifest.extensions.map((entry) => [entry.id, encodeDataUrl(entry, extensionBytes.get(`${entry.id}.js`))]))) })) : projectText;
|
|
385
|
+
const storageAssets = /* @__PURE__ */ new Map();
|
|
386
|
+
for (const [name, kind] of references) {
|
|
387
|
+
const [id, format] = name.split(".");
|
|
388
|
+
const type = assetTypeFor(storage, kind, format);
|
|
389
|
+
const asset = storage.createAsset(type, format, bytes.get(name).slice(), null, true);
|
|
390
|
+
if (asset.assetId !== id) return unsupported(`Asset hash mismatch: ${name}`);
|
|
391
|
+
storageAssets.set(assetKey(type, id, format), asset);
|
|
392
|
+
}
|
|
393
|
+
return {
|
|
394
|
+
versions,
|
|
395
|
+
files,
|
|
396
|
+
directory,
|
|
397
|
+
bytes,
|
|
398
|
+
extensionBytes,
|
|
399
|
+
project,
|
|
400
|
+
loadText,
|
|
401
|
+
storageAssets,
|
|
402
|
+
embedded: extensionManifest
|
|
403
|
+
};
|
|
404
|
+
}
|
|
405
|
+
var sameBytes = (a, b) => a.length === b.length && a.every((value, index) => value === b[index]);
|
|
406
|
+
async function readFolderUpdate(source, previous) {
|
|
407
|
+
const { directory, versions } = source;
|
|
408
|
+
try {
|
|
409
|
+
const [assets, extensions, project] = await Promise.all([
|
|
410
|
+
readDirectory(directory, "assets"),
|
|
411
|
+
readDirectory(directory, "extensions"),
|
|
412
|
+
getFile(directory, projectFile)
|
|
413
|
+
]);
|
|
414
|
+
const [assetNames, extensionNames] = await Promise.all([readNames(assets), readNames(extensions)]);
|
|
415
|
+
if (!sameNames(assetNames, source.bytes.keys()) || !sameNames(extensionNames, source.extensionBytes.keys())) return "structure";
|
|
416
|
+
if ((await Promise.all([
|
|
417
|
+
...["sb3-source.json", "embedded-extensions.json"].map(async (name) => fileVersion(await getFile(directory, name)) === versions.get(name)),
|
|
418
|
+
...[...assetNames].map(async (name) => fileVersion(await getFile(assets, name)) === versions.get(`assets/${name}`)),
|
|
419
|
+
...[...extensionNames].map(async (name) => fileVersion(await getFile(extensions, name)) === versions.get(`extensions/${name}`))
|
|
420
|
+
])).includes(false)) return "structure";
|
|
421
|
+
const version = fileVersion(project);
|
|
422
|
+
if (version === versions.get("project.source.json")) return null;
|
|
423
|
+
if ((previous === null || previous === void 0 ? void 0 : previous.version) === version) return previous;
|
|
424
|
+
const bytes = await fileBytes(project);
|
|
425
|
+
if (sameBytes(bytes, source.files.get("project.source.json"))) {
|
|
426
|
+
versions.set(projectFile, version);
|
|
427
|
+
return null;
|
|
428
|
+
}
|
|
429
|
+
const updated = parseProject(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
|
|
430
|
+
if (!equal(source.project.extensionURLs, updated.extensionURLs)) return "structure";
|
|
431
|
+
return {
|
|
432
|
+
version,
|
|
433
|
+
bytes,
|
|
434
|
+
project: updated
|
|
435
|
+
};
|
|
436
|
+
} catch (error) {
|
|
437
|
+
return error instanceof FolderError ? "structure" : "waiting";
|
|
438
|
+
}
|
|
439
|
+
}
|
|
440
|
+
async function assertFolderUnchanged(source) {
|
|
441
|
+
try {
|
|
442
|
+
const [assets, extensions] = await Promise.all([readDirectory(source.directory, "assets"), readDirectory(source.directory, "extensions")]);
|
|
443
|
+
if (!sameNames(await readNames(assets), source.bytes.keys()) || !sameNames(await readNames(extensions), source.extensionBytes.keys())) throw new FolderError("conflict");
|
|
444
|
+
for (const [directory, files] of [
|
|
445
|
+
[source.directory, source.files],
|
|
446
|
+
[assets, source.bytes],
|
|
447
|
+
[extensions, source.extensionBytes]
|
|
448
|
+
]) for (const [name, bytes] of files) if (!sameBytes(await readBytes(directory, name), bytes)) throw new FolderError("conflict");
|
|
449
|
+
} catch (error) {
|
|
450
|
+
if (error instanceof FolderError || error instanceof DOMException && ["NotFoundError", "TypeMismatchError"].includes(error.name)) throw new FolderError("conflict");
|
|
451
|
+
throw error;
|
|
452
|
+
}
|
|
453
|
+
}
|
|
454
|
+
var equal = (left, right) => {
|
|
455
|
+
if (left === right) return true;
|
|
456
|
+
if (Array.isArray(left) && Array.isArray(right)) return left.length === right.length && left.every((item, index) => equal(item, right[index]));
|
|
457
|
+
if (!isObject(left) || !isObject(right)) return false;
|
|
458
|
+
const keys = Object.keys(left);
|
|
459
|
+
return keys.length === Object.keys(right).length && keys.every((key) => Object.hasOwn(right, key) && equal(left[key], right[key]));
|
|
460
|
+
};
|
|
461
|
+
var sameIdentity = (left, right) => !isObject(left) || !isObject(right) || [
|
|
462
|
+
"id",
|
|
463
|
+
"assetId",
|
|
464
|
+
"name",
|
|
465
|
+
"opcode"
|
|
466
|
+
].every((key) => !Object.hasOwn(left, key) || !Object.hasOwn(right, key) || equal(left[key], right[key]));
|
|
467
|
+
var applyChanges = (source, before, after) => {
|
|
468
|
+
if (equal(before, after)) return source === void 0 ? after : source;
|
|
469
|
+
if (Array.isArray(before) && Array.isArray(after) && Array.isArray(source) && before.length === after.length && source.length === after.length && source.every((item, index) => sameIdentity(item, before[index]))) return after.map((item, index) => applyChanges(source[index], before[index], item));
|
|
470
|
+
if (!isObject(before) || !isObject(after)) return after;
|
|
471
|
+
const result = Object.assign(Object.create(null), isObject(source) ? source : {});
|
|
472
|
+
for (const key of Object.keys(before)) if (!Object.hasOwn(after, key)) delete result[key];
|
|
473
|
+
else if (!equal(before[key], after[key])) result[key] = applyChanges(Object.hasOwn(result, key) ? result[key] : void 0, before[key], after[key]);
|
|
474
|
+
for (const key of Object.keys(after)) if (!Object.hasOwn(before, key)) result[key] = after[key];
|
|
475
|
+
return result;
|
|
476
|
+
};
|
|
477
|
+
/** The asset files a project refers to, by file name, with the kind of list that refers to each. */
|
|
478
|
+
var projectAssets = (project) => {
|
|
479
|
+
var _project$customFonts;
|
|
480
|
+
const names = /* @__PURE__ */ new Map();
|
|
481
|
+
for (const target of project.targets) for (const kind of ["costumes", "sounds"]) {
|
|
482
|
+
var _target$kind;
|
|
483
|
+
const entries = (_target$kind = target[kind]) !== null && _target$kind !== void 0 ? _target$kind : [];
|
|
484
|
+
if (!Array.isArray(entries)) return unsupported("Invalid asset list");
|
|
485
|
+
for (const entry of entries) {
|
|
486
|
+
if (!isObject(entry) || typeof entry.assetId !== "string" || !/^[a-f0-9]{32}$/u.test(entry.assetId) || typeof entry.dataFormat !== "string" || entry.md5ext !== `${entry.assetId}.${entry.dataFormat}`) return unsupported("Invalid asset reference");
|
|
487
|
+
if (!(kind === "sounds" ? /^(wav|mp3)$/u.test(entry.dataFormat) : /^(svg|png|bmp|jpg|jpeg|gif)$/u.test(entry.dataFormat))) return unsupported(`Unsupported asset reference: ${entry.md5ext}`);
|
|
488
|
+
names.set(entry.md5ext, kind);
|
|
489
|
+
}
|
|
490
|
+
}
|
|
491
|
+
const fonts = (_project$customFonts = project.customFonts) !== null && _project$customFonts !== void 0 ? _project$customFonts : [];
|
|
492
|
+
if (!Array.isArray(fonts)) return unsupported("Invalid customFonts list");
|
|
493
|
+
for (const font of fonts) {
|
|
494
|
+
if (!isObject(font) || font.system !== false || font.md5ext === void 0) continue;
|
|
495
|
+
if (typeof font.md5ext !== "string" || !/^[a-f0-9]{32}\.(ttf|otf|woff2?)$/u.test(font.md5ext)) return unsupported("Invalid font asset reference");
|
|
496
|
+
names.set(font.md5ext, "fonts");
|
|
497
|
+
}
|
|
498
|
+
return names;
|
|
499
|
+
};
|
|
500
|
+
/**
|
|
501
|
+
* Applies the edits between `before` and `after` (both from the VM) to the project read from the folder, keeping the
|
|
502
|
+
* fields and order the VM does not know. Sprites are matched by `identity` (by name without it): a sprite with the
|
|
503
|
+
* same id keeps its folder entry under a new name, and added or removed sprites are added or removed. The asset files
|
|
504
|
+
* the result needs are the caller's to write. Returns `null` without edits.
|
|
505
|
+
*/
|
|
506
|
+
function projectChanges(source, before, after, identity) {
|
|
507
|
+
var _identity$before, _identity$after;
|
|
508
|
+
const beforeIds = (_identity$before = identity === null || identity === void 0 ? void 0 : identity.before) !== null && _identity$before !== void 0 ? _identity$before : before.targets.map(targetKey);
|
|
509
|
+
const afterIds = (_identity$after = identity === null || identity === void 0 ? void 0 : identity.after) !== null && _identity$after !== void 0 ? _identity$after : after.targets.map(targetKey);
|
|
510
|
+
if (beforeIds.length !== before.targets.length || afterIds.length !== after.targets.length) return unsupported("The targets could not be identified");
|
|
511
|
+
projectAssets(after);
|
|
512
|
+
if (after.turboWarpPlus !== void 0) return unsupported("Plus extension manifests are not saved to a project folder");
|
|
513
|
+
if (equal(before, after) && equal([...beforeIds], [...afterIds])) return null;
|
|
514
|
+
const { targets: sourceTargets } = source, sourceOther = _objectWithoutProperties(source, _excluded);
|
|
515
|
+
const { targets: beforeTargets } = before, beforeOther = _objectWithoutProperties(before, _excluded2);
|
|
516
|
+
const { targets: afterTargets } = after, afterOther = _objectWithoutProperties(after, _excluded3);
|
|
517
|
+
const originals = new Map(sourceTargets.map((target) => [targetKey(target), target]));
|
|
518
|
+
const previous = new Map(beforeTargets.map((target, index) => [beforeIds[index], target]));
|
|
519
|
+
const targets = afterTargets.map((target, index) => {
|
|
520
|
+
const prior = previous.get(afterIds[index]);
|
|
521
|
+
if (!prior) return target;
|
|
522
|
+
const original = originals.get(targetKey(prior));
|
|
523
|
+
if (!original) return unsupported("The original target could not be identified");
|
|
524
|
+
return applyChanges(original, prior, target);
|
|
525
|
+
});
|
|
526
|
+
let ordered = targets;
|
|
527
|
+
if (equal([...beforeIds], [...afterIds])) {
|
|
528
|
+
const position = new Map(sourceTargets.map((target, index) => [targetKey(target), index]));
|
|
529
|
+
const place = (index) => {
|
|
530
|
+
var _position$get;
|
|
531
|
+
return (_position$get = position.get(targetKey(beforeTargets[index]))) !== null && _position$get !== void 0 ? _position$get : index;
|
|
532
|
+
};
|
|
533
|
+
ordered = targets.map((target, index) => ({
|
|
534
|
+
target,
|
|
535
|
+
at: place(index)
|
|
536
|
+
})).sort((a, b) => a.at - b.at).map((entry) => entry.target);
|
|
537
|
+
}
|
|
538
|
+
const other = applyChanges(sourceOther, beforeOther, afterOther);
|
|
539
|
+
if (!equal(before.extensionURLs, after.extensionURLs)) {
|
|
540
|
+
const urls = applyChanges(source.extensionURLs, extensionURLs(before), extensionURLs(after));
|
|
541
|
+
if (after.extensionURLs === void 0 && !Object.keys(urls).length) delete other.extensionURLs;
|
|
542
|
+
else other.extensionURLs = urls;
|
|
543
|
+
}
|
|
544
|
+
const result = {};
|
|
545
|
+
for (const key of Object.keys(source)) if (key === "targets") result.targets = ordered;
|
|
546
|
+
else if (Object.hasOwn(other, key)) result[key] = other[key];
|
|
547
|
+
for (const key of Object.keys(other)) if (!Object.hasOwn(result, key)) result[key] = other[key];
|
|
548
|
+
return result;
|
|
549
|
+
}
|
|
550
|
+
// src/folder-registry.ts
|
|
551
|
+
var folders = /* @__PURE__ */ new WeakMap();
|
|
552
|
+
var registrations = /* @__PURE__ */ new Set();
|
|
553
|
+
var announce = () => {
|
|
554
|
+
for (const listener of [...registrations]) listener();
|
|
555
|
+
};
|
|
556
|
+
function registerFolder(vm, folder) {
|
|
557
|
+
folders.set(vm, folder);
|
|
558
|
+
announce();
|
|
559
|
+
return () => {
|
|
560
|
+
if (folders.get(vm) === folder) folders.delete(vm);
|
|
561
|
+
announce();
|
|
562
|
+
};
|
|
563
|
+
}
|
|
564
|
+
/**
|
|
565
|
+
* Calls `listener` with the project folder mounted for `vm` and the directory open in it, now and whenever a folder is
|
|
566
|
+
* mounted, opened, closed or saved. Returns the function that stops it.
|
|
567
|
+
*/
|
|
568
|
+
function followProjectFolder(vm, listener) {
|
|
569
|
+
let unsubscribe = () => {};
|
|
570
|
+
let followed;
|
|
571
|
+
const update = () => {
|
|
572
|
+
var _folder$directory;
|
|
573
|
+
const folder = folders.get(vm);
|
|
574
|
+
if (folder !== followed) {
|
|
575
|
+
unsubscribe();
|
|
576
|
+
followed = folder;
|
|
577
|
+
unsubscribe = folder ? folder.subscribe(() => listener(folder, folder.directory)) : () => {};
|
|
578
|
+
}
|
|
579
|
+
listener(folder, (_folder$directory = folder === null || folder === void 0 ? void 0 : folder.directory) !== null && _folder$directory !== void 0 ? _folder$directory : null);
|
|
580
|
+
};
|
|
581
|
+
registrations.add(update);
|
|
582
|
+
update();
|
|
583
|
+
return () => {
|
|
584
|
+
registrations.delete(update);
|
|
585
|
+
unsubscribe();
|
|
586
|
+
};
|
|
587
|
+
}
|
|
588
|
+
export { _asyncIterator as C, _objectSpread2 as S, readFolder as _, assetKey as a, unsupported as b, extensionsFile as c, manifestFile as d, parseProject as f, projectFile as g, projectChanges as h, assertFolderUnchanged as i, fileVersion as l, projectAssets as m, registerFolder as n, assetTypeFor as o, planExtensionSave as p, FolderError as r, equal as s, followProjectFolder as t, isObject as u, readFolderUpdate as v, _objectWithoutProperties as x, sameBytes as y };
|