@sasjs/cli 6.19.1 → 6.19.2

package/build/commands/build/internal/mockSite/assets/boot.js

@@ -114,13 +114,41 @@
     stamp = ''
   }
 
-  // Registered relative to the page, and scoped to the directory it sits in:
-  // the site is served from the origin root on one host and from a folder on
-  // another (a demonstration site beside its own docs), and the worker's scope
-  // has to follow the page rather than assume the root.
+  // Registered against the loader's own URL, which sits in <base>/host/, and
+  // scoped to the folder above it: the site is served from the origin root on
+  // one host and from a folder on another (a demonstration site beside its own
+  // docs). The page cannot be the reference - at `<base>` with no trailing
+  // slash a page-relative URL names the origin root, and './' resolves to '/',
+  // which is the mis-registration this is here to avoid.
+  //
+  // The tag the build emits is absolute (`<base>/host/boot.js`) when the target
+  // names a folder, and relative (`host/boot.js`) when it does not - so a site
+  // published in a folder without naming it depends on its own URL ending in a
+  // slash - and in both cases the loader's own URL then carries `<base>`. The
+  // fallback below is for the case where there is no currentScript to read.
+  var loaderSrc = (script && script.src) || loaderUrl()
+
+  // The loader always sits in <base>/host/, so without a currentScript the page
+  // still names the base. A path that does not end in a slash is ambiguous: it
+  // is the folder when its last segment has no dot (`/demo`), and a file when it
+  // does (`/demo/index.html`) - only the second has a segment to drop.
+  // `location.href` cannot do this: one level above `/demo` is the origin root.
+  function loaderUrl() {
+    var page = location.pathname
+    var lastSegment = page.slice(page.lastIndexOf('/') + 1)
+    var base
+
+    if (lastSegment.indexOf('.') === -1) {
+      base = page.charAt(page.length - 1) === '/' ? page : page + '/'
+    } else {
+      base = page.slice(0, page.lastIndexOf('/') + 1)
+    }
+
+    return location.origin + base + 'host/boot.js'
+  }
   navigator.serviceWorker
-    .register(new URL('sw.js' + stamp, location.href).href, {
-      scope: './',
+    .register(new URL('../sw.js' + stamp, loaderSrc).href, {
+      scope: new URL('../', loaderSrc).pathname,
       updateViaCache: 'none'
     })
     .then(function () {

package/build/commands/build/internal/mockSite/mockSite.js

@@ -517,8 +517,9 @@ var escapeAttribute = function (value) {
  * order, plus the inline snippets some pages use to set up a global before the
  * bundle runs - so the host does not dictate how the app is built.
  */
-var bootTag = function (scripts, version) {
-    return "<script src=\"host/boot.js?v=".concat(version, "\" data-scripts='").concat(escapeAttribute(JSON.stringify(scripts)), "'></script>");
+var bootTag = function (scripts, version, basePath) {
+    if (basePath === void 0) { basePath = ''; }
+    return "<script src=\"".concat(basePath ? "".concat(basePath, "/host/boot.js") : 'host/boot.js', "?v=").concat(version, "\" data-scripts='").concat(escapeAttribute(JSON.stringify(scripts)), "'></script>");
 };
 /**
  * Script types the browser executes. Anything else (`application/ld+json`, a
@@ -531,28 +532,36 @@ var EXECUTABLE_TYPES = [
     'application/javascript'
 ];
 /**
- * The folder the site is published under, as a path with no trailing slash.
+ * The folder the site is published under, with a leading slash and no trailing
+ * one.
  *
  * Empty for the origin root, which is the ordinary case. A host that serves the
  * demonstration site beside its documentation (a GitHub Pages site whose root is
  * the docs) names the folder here, and every path the build emits follows it.
+ *
+ * The shapes the released build accepts keep working - a bare `demo`, a leading
+ * or trailing slash, surrounding space - and are normalised rather than
+ * refused, because a `fix(mock)` release must not fail a build that passes
+ * today. The sasjsconfig schema states the canonical form; this only rejects
+ * what could never have worked, a segment that is `.`, `..` or empty.
  */
 var normaliseBasePath = function (value) {
     if (!value)
         return '';
-    var base = String(value).trim();
-    if (!base.startsWith('/'))
-        base = '/' + base;
-    base = base.replace(/\/+$/, '');
-    var segments = base.split('/').slice(1);
+    var segments = String(value)
+        .trim()
+        .replace(/^\/+/, '')
+        .replace(/\/+$/, '')
+        .split('/');
     if (!segments.length ||
         segments.some(function (segment) {
-            return !/^[A-Za-z0-9._~-]+$/.test(segment) ||
+            return !segment ||
                 segment === '.' ||
-                segment === '..';
+                segment === '..' ||
+                !/^[A-Za-z0-9._~-]+$/.test(segment);
         }))
         throw new Error("mockWebBasePath is not a folder path: ".concat(JSON.stringify(value), ". Use a path such as \"/demo\", or leave it unset for the origin root."));
-    return base;
+    return '/' + segments.join('/');
 };
 /**
  * Tells the interface that this page is answered by the browser host.
@@ -648,7 +657,7 @@ var patchIndexHtml = function (html, version, basePath) {
         return '';
     });
     if (scripts.length) {
-        var tag = bootTag(scripts, version);
+        var tag = bootTag(scripts, version, basePath);
         patched = /<\/body>/i.test(patched)
             ? patched.replace(/<\/body>/i, "".concat(tag, "\n</body>"))
             : patched + tag;

package/build/commands/build/internal/mockSite/spec/boot.spec.js

@@ -56,15 +56,24 @@ var loadBoot = function (specs, options) {
         };
         return element;
     };
+    // The page carries an absolute boot tag, `<base>/host/boot.js`, so the
+    // loader's own URL names the folder whether or not the page URL ends in a
+    // slash - a relative tag would resolve against the page and, at `/demo`, name
+    // the origin root.
+    var pageHref = options.href || 'http://localhost:8123/';
+    var stamp = options.noStamp ? '' : '?v=abc123';
+    // the tag the build emits: absolute when the target names a folder, relative
+    // to the page when it does not
+    var loaderSrc = options.basePath
+        ? "".concat(new URL(pageHref).origin).concat(options.basePath, "/host/boot.js").concat(stamp)
+        : new URL('host/boot.js' + stamp, pageHref).href;
     var document = {
         currentScript: options.noScript
             ? null
             : {
                 // the builder stamps the boot tag with the host version, and the
                 // loader reuses that query for the worker's own URL
-                src: options.noStamp
-                    ? 'http://localhost:8123/host/boot.js'
-                    : 'http://localhost:8123/host/boot.js?v=abc123',
+                src: loaderSrc,
                 getAttribute: function (name) {
                     if (name !== 'data-scripts')
                         return null;
@@ -126,7 +135,9 @@ var loadBoot = function (specs, options) {
         }
     };
     global.location = {
-        href: options.href || 'http://localhost:8123/',
+        href: pageHref,
+        pathname: new URL(pageHref).pathname,
+        origin: new URL(pageHref).origin,
         reload: function () { return timeline.push('reload'); }
     };
     jest.spyOn(console, 'error').mockImplementation(function () { });
@@ -185,7 +196,7 @@ describe('the boot loader', function () {
                     // root on one host and from /demo beside its docs on another.
                     expect(registered).toEqual([
                         'http://localhost:8123/sw.js?v=abc123 ' +
-                            JSON.stringify({ scope: './', updateViaCache: 'none' })
+                            JSON.stringify({ scope: '/', updateViaCache: 'none' })
                     ]);
                     return [2 /*return*/];
             }
@@ -196,13 +207,104 @@ describe('the boot loader', function () {
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
-                    registered = loadBoot([], { href: 'http://localhost:8123/demo/' }).registered;
+                    registered = loadBoot([], {
+                        href: 'http://localhost:8123/demo/',
+                        basePath: '/demo'
+                    }).registered;
                     return [4 /*yield*/, settle()];
                 case 1:
                     _a.sent();
                     expect(registered).toEqual([
                         'http://localhost:8123/demo/sw.js?v=abc123 ' +
-                            JSON.stringify({ scope: './', updateViaCache: 'none' })
+                            JSON.stringify({ scope: '/demo/', updateViaCache: 'none' })
+                    ]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('registers under the folder when the page has no trailing slash', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var registered;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    registered = loadBoot([], {
+                        href: 'http://localhost:8123/demo',
+                        basePath: '/demo'
+                    }).registered;
+                    return [4 /*yield*/, settle()];
+                case 1:
+                    _a.sent();
+                    expect(registered).toEqual([
+                        'http://localhost:8123/demo/sw.js?v=abc123 ' +
+                            JSON.stringify({ scope: '/demo/', updateViaCache: 'none' })
+                    ]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('finds the folder from the page when the document has no currentScript', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var registered;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    registered = loadBoot([], {
+                        href: 'http://localhost:8123/demo/',
+                        basePath: '/demo',
+                        noScript: true
+                    }).registered;
+                    return [4 /*yield*/, settle()
+                        // no tag, no version: the fallback cannot carry the build's stamp, so this
+                        // path registers the folder's worker without a cache-busting query
+                    ];
+                case 1:
+                    _a.sent();
+                    // no tag, no version: the fallback cannot carry the build's stamp, so this
+                    // path registers the folder's worker without a cache-busting query
+                    expect(registered).toEqual([
+                        'http://localhost:8123/demo/sw.js ' +
+                            JSON.stringify({ scope: '/demo/', updateViaCache: 'none' })
+                    ]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('treats a path with no trailing slash as the folder, not a file', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var registered;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    registered = loadBoot([], {
+                        href: 'http://localhost:8123/demo',
+                        basePath: '/demo',
+                        noScript: true
+                    }).registered;
+                    return [4 /*yield*/, settle()];
+                case 1:
+                    _a.sent();
+                    expect(registered).toEqual([
+                        'http://localhost:8123/demo/sw.js ' +
+                            JSON.stringify({ scope: '/demo/', updateViaCache: 'none' })
+                    ]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('drops a file name from the path, and keeps the folder above it', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var registered;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    registered = loadBoot([], {
+                        href: 'http://localhost:8123/demo/index.html',
+                        basePath: '/demo',
+                        noScript: true
+                    }).registered;
+                    return [4 /*yield*/, settle()];
+                case 1:
+                    _a.sent();
+                    expect(registered).toEqual([
+                        'http://localhost:8123/demo/sw.js ' +
+                            JSON.stringify({ scope: '/demo/', updateViaCache: 'none' })
                     ]);
                     return [2 /*return*/];
             }

package/build/commands/build/internal/mockSite/spec/mockSite.spec.js

@@ -375,9 +375,9 @@ describe('browser-hosted build', function () {
                     _a.sent();
                     html = fs_1.default.readFileSync(path_1.default.join(out(), 'index.html'), 'utf8');
                     expect(html).toContain('serverurl="/demo"');
-                    // the loader and the host's files stay relative to the page, so the same
-                    // build works at the origin root and under the folder
-                    expect(html).toContain('<script src="host/boot.js?v=');
+                    // the boot tag is absolute and names the folder, so a page at `/demo` with
+                    // no trailing slash still loads the loader from `/demo/host/`
+                    expect(html).toContain('<script src="/demo/host/boot.js?v=');
                     return [2 /*return*/];
             }
         });
@@ -395,6 +395,50 @@ describe('browser-hosted build', function () {
             }
         });
     }); });
+    it('normalises the folder shapes the released build already accepts', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, _b, value, html_1, e_3_1, html;
+        var e_3, _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    _d.trys.push([0, 5, 6, 7]);
+                    _a = __values(['/demo/', ' /demo ', 'demo']), _b = _a.next();
+                    _d.label = 1;
+                case 1:
+                    if (!!_b.done) return [3 /*break*/, 4];
+                    value = _b.value;
+                    return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target({ mockWebBasePath: value }))];
+                case 2:
+                    _d.sent();
+                    html_1 = fs_1.default.readFileSync(path_1.default.join(out(), 'index.html'), 'utf8');
+                    expect(html_1).toContain('serverurl="/demo"');
+                    _d.label = 3;
+                case 3:
+                    _b = _a.next();
+                    return [3 /*break*/, 1];
+                case 4: return [3 /*break*/, 7];
+                case 5:
+                    e_3_1 = _d.sent();
+                    e_3 = { error: e_3_1 };
+                    return [3 /*break*/, 7];
+                case 6:
+                    try {
+                        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                    }
+                    finally { if (e_3) throw e_3.error; }
+                    return [7 /*endfinally*/];
+                case 7: 
+                // explicit empty is the origin root, as it was before the option existed
+                return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target({ mockWebBasePath: '' }))];
+                case 8:
+                    // explicit empty is the origin root, as it was before the option existed
+                    _d.sent();
+                    html = fs_1.default.readFileSync(path_1.default.join(out(), 'index.html'), 'utf8');
+                    expect(html).toContain('serverurl=""');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('points the app at itself and installs the boot loader', function () { return __awaiter(void 0, void 0, void 0, function () {
         var html;
         return __generator(this, function (_a) {
@@ -630,7 +674,7 @@ describe('browser-hosted build', function () {
     }); });
     it('stops seeding bytes once the drive budget is spent, and names the file', function () { return __awaiter(void 0, void 0, void 0, function () {
         var chunk, _a, _b, name_1, seed, seeded;
-        var e_3, _c;
+        var e_4, _c;
         var _d;
         return __generator(this, function (_e) {
             switch (_e.label) {
@@ -643,12 +687,12 @@ describe('browser-hosted build', function () {
                             fs_1.default.writeFileSync(path_1.default.join(root, 'sasjsbuild', 'mock-storage', name_1), chunk);
                         }
                     }
-                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                    catch (e_4_1) { e_4 = { error: e_4_1 }; }
                     finally {
                         try {
                             if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
                         }
-                        finally { if (e_3) throw e_3.error; }
+                        finally { if (e_4) throw e_4.error; }
                     }
                     return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())
                         // the budget is spent in path order, so the drive is the same on every host:
@@ -734,7 +778,7 @@ describe('browser-hosted build', function () {
      */
     it('builds an interface that has no services, and says the drive is empty', function () { return __awaiter(void 0, void 0, void 0, function () {
         var _a, _b, folder, warn, result;
-        var e_4, _c;
+        var e_5, _c;
         var _d;
         return __generator(this, function (_e) {
             switch (_e.label) {
@@ -749,12 +793,12 @@ describe('browser-hosted build', function () {
                             });
                         }
                     }
-                    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                    catch (e_5_1) { e_5 = { error: e_5_1 }; }
                     finally {
                         try {
                             if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
                         }
-                        finally { if (e_4) throw e_4.error; }
+                        finally { if (e_5) throw e_5.error; }
                     }
                     warn = jest.spyOn((_d = process.logger) !== null && _d !== void 0 ? _d : console, 'warn');
                     return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
@@ -776,7 +820,7 @@ describe('browser-hosted build', function () {
      */
     it('warns when the build folder holds only folders that are not programs', function () { return __awaiter(void 0, void 0, void 0, function () {
         var _a, _b, folder, warn, result;
-        var e_5, _c;
+        var e_6, _c;
         var _d;
         return __generator(this, function (_e) {
             switch (_e.label) {
@@ -790,12 +834,12 @@ describe('browser-hosted build', function () {
                             });
                         }
                     }
-                    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                    catch (e_6_1) { e_6 = { error: e_6_1 }; }
                     finally {
                         try {
                             if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
                         }
-                        finally { if (e_5) throw e_5.error; }
+                        finally { if (e_6) throw e_6.error; }
                     }
                     write(path_1.default.join(root, 'sasjsbuild', 'docs', 'index.html'), '<html></html>');
                     warn = jest.spyOn((_d = process.logger) !== null && _d !== void 0 ? _d : console, 'warn');
@@ -898,8 +942,8 @@ describe('browser-hosted build', function () {
         });
     }); });
     it('refuses a mockWebFolder that would delete the project or its inputs', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var _a, _b, mockWebFolder, e_6_1;
-        var e_6, _c;
+        var _a, _b, mockWebFolder, e_7_1;
+        var e_7, _c;
         return __generator(this, function (_d) {
             switch (_d.label) {
                 case 0:
@@ -930,14 +974,14 @@ describe('browser-hosted build', function () {
                     return [3 /*break*/, 1];
                 case 4: return [3 /*break*/, 7];
                 case 5:
-                    e_6_1 = _d.sent();
-                    e_6 = { error: e_6_1 };
+                    e_7_1 = _d.sent();
+                    e_7 = { error: e_7_1 };
                     return [3 /*break*/, 7];
                 case 6:
                     try {
                         if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
                     }
-                    finally { if (e_6) throw e_6.error; }
+                    finally { if (e_7) throw e_7.error; }
                     return [7 /*endfinally*/];
                 case 7:
                     expect(fs_1.default.existsSync(path_1.default.join(root, 'client', 'dist', 'index.html'))).toBe(true);

package/build/types/index.d.ts

@@ -5,3 +5,4 @@ export { TargetScope } from './targetScope';
 export { TestFlow, Coverage, CoverageReport, CoverageSummary, CoverageType, CoverageState, TestResults, TestResultStatus, TestDescription, TestResult, TestResultDescription, TestResultCsv } from './testing';
 export { Flow, FlowWave, FlowWaveJob } from './flow';
 export * from './log';
+export * from './mockWebBasePath';

package/build/types/index.js

@@ -24,3 +24,4 @@ Object.defineProperty(exports, "CoverageType", { enumerable: true, get: function
 Object.defineProperty(exports, "CoverageState", { enumerable: true, get: function () { return testing_1.CoverageState; } });
 Object.defineProperty(exports, "TestResultStatus", { enumerable: true, get: function () { return testing_1.TestResultStatus; } });
 __exportStar(require("./log"), exports);
+__exportStar(require("./mockWebBasePath"), exports);

package/build/types/mockWebBasePath.d.ts

@@ -0,0 +1,24 @@
+/**
+ * `mockWebBasePath` on a stream config.
+ *
+ * A `.ts` rather than a `.d.ts` so it compiles into `build/types/` with the
+ * rest of the package: tsc does not emit an ambient input file, and this one
+ * would otherwise type the CLI's own build and vanish from the published one.
+ *
+ * The option belongs to the mock target the CLI reads, but `StreamConfig` in
+ * @sasjs/utils 4.9.0 predates it, so without this the property is invisible to
+ * anyone typing a sasjsconfig and to anything that round-trips a target through
+ * the type. The field lands upstream in sasjs/utils#317; when the pin moves past
+ * that release, delete this file and the declaration merges from the package
+ * itself.
+ */
+export {};
+declare module '@sasjs/utils/types/config' {
+    interface StreamConfig {
+        /**
+         * The folder the mock site is published in, as a path with no trailing
+         * slash (`/demo`). Unset means the origin root.
+         */
+        mockWebBasePath?: string;
+    }
+}

package/build/types/mockWebBasePath.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -125,5 +125,5 @@
     "ws": "8.21.0",
     "nanoid": "3.3.18"
   },
-  "version": "6.19.1"
+  "version": "6.19.2"
 }