toolaby 1.6.3 → 1.7.0

package/lib/manifest.js

@@ -6,7 +6,9 @@
  * the storage permission; the platform's address as a host permission and
  * for externally_connectable (the site's sign-in and purchase handoffs); a
  * module service worker when the manifest names none, or names one that is
- * not there; the Wall's popup in front of the extension's own — and its
+ * not there — and in front of the extension's own background, the Wall's,
+ * which runs it and then starts the platform (wallWorkerSource), so nothing
+ * of theirs is edited; the Wall's popup in front of the extension's own — and its
  * side panel in front of the extension's side panel — which the
  * configuration then remembers; and the extension's identity — the `key`
  * that fixes its id, which the tool key is bound to (identity.ts) — unless
@@ -18,6 +20,55 @@
 export const WALL_POPUP = 'toolaby-popup.html';
 export const WALL_SIDE_PANEL = 'toolaby-sidepanel.html';
 export const WORKER_LINES = "import { toolaby } from './toolaby.js';\n\ntoolaby.startBackground();\n";
+/** The Wall's background: the one it writes when the manifest names none, and the one it stands in front of theirs. */
+export const WALL_WORKER = 'toolaby.background.js';
+/** The client as a classic script (a global `Toolaby`): what a classic background loads with importScripts(). */
+export const CLASSIC_CLIENT = 'toolaby-client.js';
+/** The line in the Wall's background that names the extension's own, which it runs: read back when wired again. */
+const WRAPS = /^\/\/ toolaby-wraps: (.+)$/m;
+/** A background the Wall's can name in the code it writes: a path inside the folder, plain characters, a script. */
+const SCRIPT_PATH = /^(?!.*\.\.)(?!.*\/\/)[A-Za-z0-9_][A-Za-z0-9_\-./]*\.m?js$/;
+/** Code without its comments, strings kept whole, so a `//` inside one is not taken for a comment. */
+export function withoutComments(text) {
+    return text.replace(/("(?:[^"\\\n]|\\.)*"|'(?:[^'\\\n]|\\.)*'|`(?:[^`\\]|\\.)*`)|\/\*[\s\S]*?\*\/|\/\/[^\n]*/g, (m, str) => (str ? m : ''));
+}
+/** Whether a background already starts the Wall itself: then it is left as it is. */
+export const startsPlatform = (source) => /\b(?:startBackground|ensureBackground)\s*\(/.test(withoutComments(source));
+/** The extension's own background the Wall's runs, read from the Wall's; null for any other file. */
+export const wrappedBy = (source) => source?.match(WRAPS)?.[1]?.trim() || null;
+/**
+ * The Wall's background in front of the extension's own (`file`, beside `wraps`, so a relative importScripts() of
+ * theirs still finds its files): it runs theirs as before, then starts the Wall unless theirs did — ensureBackground(),
+ * so a background that starts it with handlers of its own keeps them. A module background gets a module; a classic
+ * one a classic script, which loads the client as one (CLASSIC_CLIENT), so its importScripts() work as they did. The
+ * classic one carries the configuration it starts with — the key and the pages of toolaby.config.js — which wiring
+ * again rewrites with it.
+ */
+export function wallWorkerSource(b, config) {
+    const depth = b.file.split('/').length - 1;
+    const up = '../'.repeat(depth);
+    const own = b.wraps.slice(b.wraps.lastIndexOf('/') + 1);
+    const head = `// The Wall's background, in front of yours: ${b.wraps} runs as it did, then the Wall starts.\n// Written by the Wall's wiring (toolaby wire): keep it, never edit it. Your code stays in ${b.wraps}.\n// toolaby-wraps: ${b.wraps}\n`;
+    if (!b.classic)
+        return `${head}import { toolaby } from '${up || './'}toolaby.js';\nimport './${own}';\n\ntoolaby.ensureBackground();\n`;
+    const c = config ?? { key: '', appPopup: '', appSidePanel: '' };
+    return `${head}importScripts('${up}${CLASSIC_CLIENT}');\nself.toolaby = Toolaby(${JSON.stringify({ key: c.key, appPopup: c.appPopup, appSidePanel: c.appSidePanel })});\nimportScripts('${own}');\ntoolaby.ensureBackground();\n`;
+}
+/** What toolaby.config.js starts the Wall with, read from its text: what a classic background of the Wall's carries. */
+export function configValues(text) {
+    const code = withoutComments(text);
+    const get = (name) => code.match(new RegExp(`${name}:\\s*'([^']*)'`))?.[1];
+    const key = get('key');
+    return key ? { key, appPopup: get('appPopup') ?? '', appSidePanel: get('appSidePanel') ?? '' } : null;
+}
+/** A name a background can be loaded by, for one that has none: its characters kept where they can be, the rest a dash. */
+export const loadableName = (file) => {
+    const clean = file.split('/').filter((p) => p && p !== '.' && p !== '..').map((p) => p.replace(/[^A-Za-z0-9_\-.]+/g, '-').replace(/^[^A-Za-z0-9_]+/, '')).filter(Boolean).join('/');
+    const js = /\.m?js$/.test(clean) ? clean : `${clean.replace(/\.[^./]*$/, '') || 'background'}.js`;
+    return js.replace(/-+(?=\.m?js$)/, '');
+};
+/** The background the manifest names, as the folder spells it: "./background.js" is background.js. */
+export const namedWorker = (manifest) => typeof manifest?.background?.service_worker === 'string' ? manifest.background.service_worker.trim().replace(/^(\.\/)+/, '') || null : null;
 /**
  * Whether an earlier wiring left the extension's own pages drawing the panel: a configuration that says '' for both
  * pages while the manifest names none of the Wall's. That is what `create` makes, and the "your popup first" shape
@@ -37,11 +88,19 @@ export function drawsItself(manifest, oldConfig) {
 export function wireManifest(input, o) {
     const manifest = JSON.parse(JSON.stringify(input));
     const did = [];
+    const added = [];
+    const host = (() => { try {
+        return new URL(o.site).host;
+    }
+    catch {
+        return o.site;
+    } })();
     // The identity: the manifest's own key stays (the platform adopts it); otherwise the platform's goes in, and the unpacked extension's id is known before it loads.
     const own = typeof manifest.key === 'string' && manifest.key.trim() ? manifest.key.trim() : null;
     if (!own && o.manifestKey) {
         manifest.key = o.manifestKey;
         did.push('a "key", so the extension keeps one id across reloads and machines');
+        added.push('key');
     }
     const manifestKey = own ?? o.manifestKey ?? null;
     const add = (list, value) => { const arr = Array.isArray(list) ? [...list] : []; if (!arr.includes(value))
@@ -49,15 +108,20 @@ export function wireManifest(input, o) {
     if (!(Array.isArray(manifest.permissions) && manifest.permissions.includes('storage'))) {
         manifest.permissions = add(manifest.permissions, 'storage');
         did.push('the "storage" permission');
+        added.push('storage');
     }
     if (!(Array.isArray(manifest.host_permissions) && manifest.host_permissions.includes(`${o.site}/*`))) {
         manifest.host_permissions = add(manifest.host_permissions, `${o.site}/*`);
         did.push(`a host permission for ${o.site}`);
+        if (!added.includes(host))
+            added.push(host);
     }
     const ec = manifest.externally_connectable ?? {};
     if (!(Array.isArray(ec.matches) && ec.matches.includes(`${o.site}/*`))) {
         manifest.externally_connectable = { ...ec, matches: add(ec.matches, `${o.site}/*`) };
         did.push(`externally_connectable for ${o.site}`);
+        if (!added.includes(host))
+            added.push(host);
     }
     // The extension's own popup: the manifest's, or the one remembered when the manifest already names the Wall's.
     const declared = typeof manifest.action?.default_popup === 'string' ? manifest.action.default_popup : null;
@@ -67,6 +131,11 @@ export function wireManifest(input, o) {
         manifest.action = { ...manifest.action, default_popup: WALL_POPUP };
         did.push(`the Wall's popup in front of ${appPopup}: it opens on to yours while the device may, and shows the panel when it may not`);
     }
+    // Asked to keep the extension's own in front after a wiring stood the Wall's there: theirs goes back.
+    if (o.ownInFront && declared === WALL_POPUP && ownPopup) {
+        manifest.action = { ...manifest.action, default_popup: ownPopup };
+        did.push(`${ownPopup} back in front: toolaby.showPaywall() opens the Wall's popup`);
+    }
     // The extension's own side panel, the same way: the Wall's in front, with the permission a side panel needs.
     // Chrome spells it side_panel.default_path, Firefox sidebar_action.default_panel; a manifest may carry both.
     const theirs = (v) => (typeof v === 'string' && v !== WALL_SIDE_PANEL ? v : null);
@@ -75,7 +144,15 @@ export function wireManifest(input, o) {
     const ours = declaredPanel === WALL_SIDE_PANEL || declaredSidebar === WALL_SIDE_PANEL;
     const ownSidePanel = theirs(declaredPanel) ?? theirs(declaredSidebar) ?? (ours ? o.rememberedSidePanel || null : null);
     const appSidePanel = o.ownInFront ? null : ownSidePanel;
-    if (o.ownInFront) { /* the extension's own side panel stays in front, as its popup does */ }
+    if (o.ownInFront) {
+        // The extension's own side panel stays in front, as its popup does — and goes back there after a wiring put the Wall's.
+        if (declaredPanel === WALL_SIDE_PANEL && ownSidePanel) {
+            manifest.side_panel = { ...manifest.side_panel, default_path: ownSidePanel };
+            did.push(`${ownSidePanel} back in front: toolaby.showPaywall() opens the Wall's side panel`);
+        }
+        if (declaredSidebar === WALL_SIDE_PANEL && ownSidePanel)
+            manifest.sidebar_action = { ...manifest.sidebar_action, default_panel: ownSidePanel };
+    }
     else if (theirs(declaredPanel)) {
         manifest.side_panel = { ...manifest.side_panel, default_path: WALL_SIDE_PANEL };
         if (!(Array.isArray(manifest.permissions) && manifest.permissions.includes('sidePanel')))
@@ -87,16 +164,40 @@ export function wireManifest(input, o) {
         manifest.sidebar_action = { ...manifest.sidebar_action, default_panel: WALL_SIDE_PANEL };
         did.push(`the Wall's side panel in front of ${declaredSidebar} in Firefox's sidebar_action too`);
     }
-    const named = typeof manifest.background?.service_worker === 'string' && manifest.background.service_worker.trim() ? manifest.background.service_worker.trim() : null;
-    let writeWorker = null;
-    let ownWorker = null;
+    // The background. None named, or named and not there: one of the Wall's alone, a module. The extension's own: left as
+    // it is, and the Wall's stood in front of it — beside it, a module for a module and a classic script for a classic
+    // one — unless it starts the Wall already. Wired again, the Wall's is written again for the one it names.
+    const named = namedWorker(manifest);
+    let background;
+    let workerMoved = false;
     if (!named || !o.has(named)) {
-        writeWorker = named ?? (o.has('background.js') ? 'toolaby.background.js' : 'background.js');
-        manifest.background = { service_worker: writeWorker, type: 'module' };
-        did.push(`a service worker, ${writeWorker} (two lines: it starts the platform)`);
+        const file = named ?? (o.has('background.js') ? WALL_WORKER : 'background.js');
+        manifest.background = { service_worker: file, type: 'module' };
+        did.push(`a service worker, ${file} (two lines: it starts the platform)`);
+        background = { kind: 'new', file };
     }
     else {
-        ownWorker = { file: named, classic: manifest.background?.type !== 'module' };
+        const source = o.workerSource ?? '';
+        const wraps = wrappedBy(source);
+        const theirs = wraps ?? named;
+        const classic = manifest.background?.type !== 'module';
+        if (!wraps && startsPlatform(source))
+            background = { kind: 'started', file: named };
+        else if (wraps && !o.has(wraps))
+            background = { kind: 'gone', file: named, wraps };
+        else if (/\.(ts|tsx|mts|cts|jsx)$/.test(theirs))
+            background = { kind: 'lines', file: theirs };
+        else if (!SCRIPT_PATH.test(theirs))
+            background = { kind: 'rename', file: theirs, to: loadableName(theirs) };
+        else {
+            const file = wraps ? named : `${theirs.includes('/') ? theirs.slice(0, theirs.lastIndexOf('/') + 1) : ''}${WALL_WORKER}`;
+            if (!wraps) {
+                manifest.background = { ...manifest.background, service_worker: file };
+                workerMoved = true;
+            }
+            background = { kind: 'wrap', file, wraps: theirs, classic };
+        }
     }
-    return { manifest, did, writeWorker, ownWorker, appPopup, appSidePanel, manifestKey, ownPopup, ownSidePanel };
+    const changed = did.length > 0 || workerMoved;
+    return { manifest, did, added, changed, background, appPopup, appSidePanel, manifestKey, ownPopup, ownSidePanel };
 }

package/lib/project.js

@@ -1,6 +1,6 @@
 // Generated from wall/src/packages/wiring/project.ts by wall/scripts/pack-create.mjs — edit there.
 /** What to tell a developer whose build ships the extension — the Wire button, the command and the Set up page all say it in these words. */
-export const BUILD_COPY_NOTE = 'A build ships this extension: make sure it copies the platform\'s files to its output — toolaby.js, toolaby.config.js and toolaby-popup.html (toolaby-sidepanel.html too, with a side panel) — the way it copies your popup.html.';
+export const BUILD_COPY_NOTE = 'A build ships this extension: make sure it copies every toolaby* file to its output — toolaby.js, toolaby.config.js, toolaby-popup.html and the rest — the way it copies your popup.html.';
 /** Always written, where the build imports from: the platform as one file (the client and the popup UI), its config, its types. */
 export const CODE_FILES = ['toolaby.config.js', 'toolaby.js', 'toolaby.d.ts'];
 /** Beside the client when the build generates the manifest: the fragment it spreads in, derived from the key (boilerplate/toolaby.manifest.js). */
@@ -161,7 +161,7 @@ export function detectProject(o) {
         const declared = typeof manifest?.action?.default_popup === 'string' ? manifest.action.default_popup : null;
         // Chrome's side_panel, else Firefox's sidebar_action: the same page, two spellings.
         const declaredPanel = typeof manifest?.side_panel?.default_path === 'string' ? manifest.side_panel.default_path : typeof manifest?.sidebar_action?.default_panel === 'string' ? manifest.sidebar_action.default_panel : null;
-        const named = typeof manifest?.background?.service_worker === 'string' ? manifest.background.service_worker : null;
+        const named = typeof manifest?.background?.service_worker === 'string' ? manifest.background.service_worker.trim().replace(/^(\.\/)+/, '') || null : null;
         const workerFile = named && has(named) ? named : 'background.js';
         return {
             kind: crxjs ? 'crxjs' : 'plain', label: crxjs ? 'CRXJS' : 'a plain extension', codeDir: '', popupDir: '', manifestFile: 'manifest.json', wrapper: true, built: crxjs ? false : built, foundManifest: null,