@sasjs/cli 3.6.6 → 3.7.5

package/build/commands/web/internal/spec/testFiles/script3.js

@@ -0,0 +1,218 @@
+"use strict";
+// game.js from SASjs/Mario
+// https://github.com/sasjs/mario/blob/main/src/js/game.js
+var requestAnimFrame = (function () {
+    return (window.requestAnimationFrame ||
+        window.webkitRequestAnimationFrame ||
+        window.mozRequestAnimationFrame ||
+        window.oRequestAnimationFrame ||
+        window.msRequestAnimationFrame ||
+        function (callback) {
+            window.setTimeout(callback, 1000 / 60);
+        });
+})();
+//create the canvas
+var canvas = document.createElement('canvas');
+var ctx = canvas.getContext('2d');
+var updateables = [];
+var fireballs = [];
+var player = new Mario.Player([0, 0]);
+//we might have to get the size and calculate the scaling
+//but this method should let us make it however big.
+//Cool!
+//TODO: Automatically scale the game to work and look good on widescreen.
+//TODO: fiddling with scaled sprites looks BETTER, but not perfect. Hmm.
+canvas.width = 762;
+canvas.height = 720;
+ctx.scale(3, 3);
+document.body.appendChild(canvas);
+//viewport
+var vX = 0, vY = 0, vWidth = 256, vHeight = 240;
+//load our images
+resources.load([
+    'sprites/player.png',
+    'sprites/enemy.png',
+    'sprites/tiles.png',
+    'sprites/playerl.png',
+    'sprites/items.png',
+    'sprites/enemyr.png'
+]);
+resources.onReady(init);
+var level;
+var sounds;
+var music;
+//initialize
+var lastTime;
+function init() {
+    music = {
+        overworld: new Audio('sounds/aboveground_bgm.ogg'),
+        underground: new Audio('sounds/underground_bgm.ogg'),
+        clear: new Audio('sounds/stage_clear.wav'),
+        death: new Audio('sounds/mariodie.wav')
+    };
+    sounds = {
+        smallJump: new Audio('sounds/jump-small.wav'),
+        bigJump: new Audio('sounds/jump-super.wav'),
+        breakBlock: new Audio('sounds/breakblock.wav'),
+        bump: new Audio('sounds/bump.wav'),
+        coin: new Audio('sounds/coin.wav'),
+        fireball: new Audio('sounds/fireball.wav'),
+        flagpole: new Audio('sounds/flagpole.wav'),
+        kick: new Audio('sounds/kick.wav'),
+        pipe: new Audio('sounds/pipe.wav'),
+        itemAppear: new Audio('sounds/itemAppear.wav'),
+        powerup: new Audio('sounds/powerup.wav'),
+        stomp: new Audio('sounds/stomp.wav')
+    };
+    Mario.oneone();
+    lastTime = Date.now();
+    main();
+}
+var gameTime = 0;
+//set up the game loop
+function main() {
+    var now = Date.now();
+    var dt = (now - lastTime) / 1000.0;
+    update(dt);
+    render();
+    lastTime = now;
+    requestAnimFrame(main);
+}
+function update(dt) {
+    gameTime += dt;
+    handleInput(dt);
+    updateEntities(dt, gameTime);
+    checkCollisions();
+}
+function handleInput(dt) {
+    if (player.piping || player.dying || player.noInput)
+        return; //don't accept input
+    if (input.isDown('RUN')) {
+        player.run();
+    }
+    else {
+        player.noRun();
+    }
+    if (input.isDown('JUMP')) {
+        player.jump();
+    }
+    else {
+        //we need this to handle the timing for how long you hold it
+        player.noJump();
+    }
+    if (input.isDown('DOWN')) {
+        player.crouch();
+    }
+    else {
+        player.noCrouch();
+    }
+    if (input.isDown('LEFT')) {
+        // 'd' or left arrow
+        player.moveLeft();
+    }
+    else if (input.isDown('RIGHT')) {
+        // 'k' or right arrow
+        player.moveRight();
+    }
+    else {
+        player.noWalk();
+    }
+}
+//update all the moving stuff
+function updateEntities(dt, gameTime) {
+    player.update(dt, vX);
+    updateables.forEach(function (ent) {
+        ent.update(dt, gameTime);
+    });
+    //This should stop the jump when he switches sides on the flag.
+    if (player.exiting) {
+        if (player.pos[0] > vX + 96)
+            vX = player.pos[0] - 96;
+    }
+    else if (level.scrolling && player.pos[0] > vX + 80) {
+        vX = player.pos[0] - 80;
+    }
+    if (player.powering.length !== 0 || player.dying) {
+        return;
+    }
+    level.items.forEach(function (ent) {
+        ent.update(dt);
+    });
+    level.enemies.forEach(function (ent) {
+        ent.update(dt, vX);
+    });
+    fireballs.forEach(function (fireball) {
+        fireball.update(dt);
+    });
+    level.pipes.forEach(function (pipe) {
+        pipe.update(dt);
+    });
+}
+//scan for collisions
+function checkCollisions() {
+    if (player.powering.length !== 0 || player.dying) {
+        return;
+    }
+    player.checkCollisions();
+    //Apparently for each will just skip indices where things were deleted.
+    level.items.forEach(function (item) {
+        item.checkCollisions();
+    });
+    level.enemies.forEach(function (ent) {
+        ent.checkCollisions();
+    });
+    fireballs.forEach(function (fireball) {
+        fireball.checkCollisions();
+    });
+    level.pipes.forEach(function (pipe) {
+        pipe.checkCollisions();
+    });
+}
+//draw the game!
+function render() {
+    updateables = [];
+    ctx.clearRect(0, 0, canvas.width, canvas.height);
+    ctx.fillStyle = level.background;
+    ctx.fillRect(0, 0, canvas.width, canvas.height);
+    //scenery gets drawn first to get layering right.
+    for (var i = 0; i < 15; i++) {
+        for (var j = Math.floor(vX / 16) - 1; j < Math.floor(vX / 16) + 20; j++) {
+            if (level.scenery[i][j]) {
+                renderEntity(level.scenery[i][j]);
+            }
+        }
+    }
+    //then items
+    level.items.forEach(function (item) {
+        renderEntity(item);
+    });
+    level.enemies.forEach(function (enemy) {
+        renderEntity(enemy);
+    });
+    fireballs.forEach(function (fireball) {
+        renderEntity(fireball);
+    });
+    //then we draw every static object.
+    for (var i = 0; i < 15; i++) {
+        for (var j = Math.floor(vX / 16) - 1; j < Math.floor(vX / 16) + 20; j++) {
+            if (level.statics[i][j]) {
+                renderEntity(level.statics[i][j]);
+            }
+            if (level.blocks[i][j]) {
+                renderEntity(level.blocks[i][j]);
+                updateables.push(level.blocks[i][j]);
+            }
+        }
+    }
+    //then the player
+    if (player.invincibility % 2 === 0) {
+        renderEntity(player);
+    }
+    //Mario goes INTO pipes, so naturally they go after.
+    level.pipes.forEach(function (pipe) {
+        renderEntity(pipe);
+    });
+}
+function renderEntity(entity) {
+    entity.render(ctx, vX, vY);
+}

package/build/commands/web/internal/spec/updateLinkTag.spec.js

@@ -26,7 +26,7 @@ describe('updateLinkTag', function () {
             source: 'image.jpeg',
             target: sasProgramPath
         });
-        (0, updateLinkTag_1.updateLinkTag)(imgTag, assetPathMap, 'image');
+        (0, updateLinkTag_1.updateLinkTag)(imgTag, assetPathMap, 'src');
         expect(imgTag.getAttribute('src')).toEqual(sasProgramPath);
     });
 });

package/build/commands/web/internal/spec/updateScriptTag.spec.js

@@ -38,6 +38,31 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -79,7 +104,7 @@ describe('updateScriptTag', function () {
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
-                    scriptTag = document.createElement('link');
+                    scriptTag = document.createElement('script');
                     sourcePath = path_1.default.join(__dirname, 'testFiles');
                     target = { serverType: utils_1.ServerType.Sas9 };
                     assetPathMap = [];
@@ -121,4 +146,124 @@ describe('updateScriptTag', function () {
             }
         });
     }); });
+    it("should update links in js script", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var sourcePath, gameTestFilePath, target, assetPathMap, scriptTag, _a, updatedContent;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    sourcePath = path_1.default.join(__dirname, 'testFiles');
+                    gameTestFilePath = path_1.default.join(sourcePath, 'script3.js');
+                    target = { serverType: utils_1.ServerType.SasViya };
+                    assetPathMap = __spreadArray(__spreadArray([], __read(gameJSSpriteLinks), false), __read(gameJSSoundLinks), false);
+                    scriptTag = document.createElement('script');
+                    _a = scriptTag;
+                    return [4 /*yield*/, (0, utils_1.readFile)(gameTestFilePath)];
+                case 1:
+                    _a.innerHTML = _b.sent();
+                    return [4 /*yield*/, (0, updateScriptTag_1.updateScriptTag)(scriptTag, sourcePath, destinationPath, target.serverType, assetPathMap)];
+                case 2:
+                    _b.sent();
+                    updatedContent = scriptTag.innerHTML;
+                    gameJSSpriteLinks.forEach(function (link) {
+                        return expect(updatedContent).toContain(link.target);
+                    });
+                    gameJSSoundLinks.forEach(function (link) {
+                        return expect(updatedContent).toContain(link.target);
+                    });
+                    return [2 /*return*/];
+            }
+        });
+    }); });
 });
+var gameJSSpriteLinks = [
+    {
+        source: 'sprites/enemy.png',
+        target: 'link-to-compiled-webv/sprites/enemy.png'
+    },
+    {
+        source: 'sprites/enemyr.png',
+        target: 'link-to-compiled-webv/sprites/enemyr.png'
+    },
+    {
+        source: 'sprites/items.png',
+        target: 'link-to-compiled-webv/sprites/items.png'
+    },
+    {
+        source: 'sprites/player.png',
+        target: 'link-to-compiled-webv/sprites/player.png'
+    },
+    {
+        source: 'sprites/playerl.png',
+        target: 'link-to-compiled-webv/sprites/playerl.png'
+    },
+    {
+        source: 'sprites/tiles.png',
+        target: 'link-to-compiled-webv/sprites/tiles.png'
+    }
+];
+var gameJSSoundLinks = [
+    {
+        source: 'sounds/aboveground_bgm.ogg',
+        target: 'link-to-compiled-webv/sounds/aboveground_bgm.ogg'
+    },
+    {
+        source: 'sounds/breakblock.wav',
+        target: 'link-to-compiled-webv/sounds/breakblock.wav'
+    },
+    {
+        source: 'sounds/bump.wav',
+        target: 'link-to-compiled-webv/sounds/bump.wav'
+    },
+    {
+        source: 'sounds/coin.wav',
+        target: 'link-to-compiled-webv/sounds/coin.wav'
+    },
+    {
+        source: 'sounds/fireball.wav',
+        target: 'link-to-compiled-webv/sounds/fireball.wav'
+    },
+    {
+        source: 'sounds/flagpole.wav',
+        target: 'link-to-compiled-webv/sounds/flagpole.wav'
+    },
+    {
+        source: 'sounds/itemAppear.wav',
+        target: 'link-to-compiled-webv/sounds/itemAppear.wav'
+    },
+    {
+        source: 'sounds/jump-small.wav',
+        target: 'link-to-compiled-webv/sounds/jump-small.wav'
+    },
+    {
+        source: 'sounds/jump-super.wav',
+        target: 'link-to-compiled-webv/sounds/jump-super.wav'
+    },
+    {
+        source: 'sounds/kick.wav',
+        target: 'link-to-compiled-webv/sounds/kick.wav'
+    },
+    {
+        source: 'sounds/mariodie.wav',
+        target: 'link-to-compiled-webv/sounds/mariodie.wav'
+    },
+    {
+        source: 'sounds/pipe.wav',
+        target: 'link-to-compiled-webv/sounds/pipe.wav'
+    },
+    {
+        source: 'sounds/powerup.wav',
+        target: 'link-to-compiled-webv/sounds/powerup.wav'
+    },
+    {
+        source: 'sounds/stage_clear.wav',
+        target: 'link-to-compiled-webv/sounds/stage_clear.wav'
+    },
+    {
+        source: 'sounds/stomp.wav',
+        target: 'link-to-compiled-webv/sounds/stomp.wav'
+    },
+    {
+        source: 'sounds/underground_bgm.ogg',
+        target: 'link-to-compiled-webv/sounds/underground_bgm.ogg'
+    }
+];

package/build/commands/web/internal/spec/updateStyleTag.spec.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @jest-environment jsdom
+ */
+export {};

package/build/commands/web/internal/spec/updateStyleTag.spec.js

@@ -0,0 +1,131 @@
+"use strict";
+/**
+ * @jest-environment jsdom
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var path_1 = __importDefault(require("path"));
+var utils_1 = require("@sasjs/utils");
+var updateStyleTag_1 = require("../updateStyleTag");
+var utils_2 = require("../../../../utils");
+describe('updateStyleTag', function () {
+    var destinationPath;
+    beforeAll(function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    destinationPath = path_1.default.join(__dirname, "cli-test-web-updateStyleTag-".concat((0, utils_1.generateTimestamp)()));
+                    return [4 /*yield*/, (0, utils_1.createFolder)(destinationPath)];
+                case 1:
+                    _a.sent();
+                    process.projectDir = destinationPath;
+                    return [4 /*yield*/, (0, utils_2.setConstants)()];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    afterAll(function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, utils_1.deleteFolder)(destinationPath)];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it("should update links in css script", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var sourcePath, styleFilePath, target, assetPathMap, scriptTag, _a, updatedContent;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    sourcePath = path_1.default.join(__dirname, 'testFiles');
+                    styleFilePath = path_1.default.join(sourcePath, 'style1.css');
+                    target = { serverType: utils_1.ServerType.SasViya };
+                    assetPathMap = __spreadArray([], __read(assetLinks), false);
+                    scriptTag = document.createElement('style');
+                    _a = scriptTag;
+                    return [4 /*yield*/, (0, utils_1.readFile)(styleFilePath)];
+                case 1:
+                    _a.innerHTML = _b.sent();
+                    return [4 /*yield*/, (0, updateStyleTag_1.updateStyleTag)(scriptTag, sourcePath, destinationPath, target.serverType, assetPathMap)];
+                case 2:
+                    _b.sent();
+                    updatedContent = scriptTag.innerHTML;
+                    assetLinks.forEach(function (link) { return expect(updatedContent).toContain(link.target); });
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});
+var assetLinks = [
+    {
+        source: 'assets/fa-solid-900.ttf',
+        target: 'link-to-compiled-webv/assets/fa-solid-900.ttf'
+    }
+];

package/build/commands/web/internal/updateAllTags.js

@@ -66,10 +66,11 @@ var utils_1 = require("@sasjs/utils");
 var getTags_1 = require("./getTags");
 var updateScriptTag_1 = require("./updateScriptTag");
 var updateLinkTag_1 = require("./updateLinkTag");
+var updateStyleTag_1 = require("./updateStyleTag");
 var updateAllTags = function (parsedHtml, _a) {
     var webSourcePathFull = _a.webSourcePathFull, destinationPath = _a.destinationPath, serverType = _a.serverType, assetPathMap = _a.assetPathMap;
     return __awaiter(void 0, void 0, void 0, function () {
-        var assetsNotFound, scriptTags, styleTags, faviconTags, linkTags, imgTags, notFoundErrors;
+        var assetsNotFound, scriptTags, styleExternalTags, styleInPageTags, styleTags, faviconTags, imgTags, sourceTags, srcTags, notFoundErrors;
         return __generator(this, function (_b) {
             switch (_b.label) {
                 case 0:
@@ -87,25 +88,38 @@ var updateAllTags = function (parsedHtml, _a) {
                         }); })];
                 case 1:
                     _b.sent();
-                    styleTags = (0, getTags_1.getStyleTags)(parsedHtml);
+                    styleExternalTags = (0, getTags_1.getStyleTags)(parsedHtml);
+                    styleInPageTags = (0, getTags_1.getStyleInPageTags)(parsedHtml);
+                    styleTags = __spreadArray(__spreadArray([], __read(styleExternalTags), false), __read(styleInPageTags), false);
+                    return [4 /*yield*/, (0, utils_1.asyncForEach)(styleTags, function (tag) { return __awaiter(void 0, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, (0, updateStyleTag_1.updateStyleTag)(tag, webSourcePathFull, destinationPath, serverType, assetPathMap).catch(function (e) { return assetsNotFound.push(e); })];
+                                    case 1:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); })];
+                case 2:
+                    _b.sent();
                     faviconTags = (0, getTags_1.getFaviconTags)(parsedHtml);
-                    linkTags = __spreadArray(__spreadArray([], __read(styleTags), false), __read(faviconTags), false);
-                    linkTags.forEach(function (tag) {
+                    faviconTags.forEach(function (tag) {
                         try {
                             (0, updateLinkTag_1.updateLinkTag)(tag, assetPathMap);
                         }
                         catch (error) {
-                            console.log(tag, error);
                             assetsNotFound.push(error);
                         }
                     });
                     imgTags = (0, getTags_1.getImgTags)(parsedHtml);
-                    imgTags.forEach(function (tag) {
+                    sourceTags = (0, getTags_1.getSourceTags)(parsedHtml);
+                    srcTags = __spreadArray(__spreadArray([], __read(imgTags), false), __read(sourceTags), false);
+                    srcTags.forEach(function (tag) {
                         try {
-                            (0, updateLinkTag_1.updateLinkTag)(tag, assetPathMap, 'image');
+                            (0, updateLinkTag_1.updateLinkTag)(tag, assetPathMap, 'src');
                         }
                         catch (error) {
-                            console.log(tag, error);
                             assetsNotFound.push(error);
                         }
                     });

package/build/commands/web/internal/updateLinkTag.d.ts

@@ -1,4 +1,4 @@
-export declare const updateLinkTag: (linkTag: HTMLLinkElement | HTMLImageElement, assetPathMap: {
+export declare const updateLinkTag: (linkTag: HTMLLinkElement | HTMLSourceElement | HTMLImageElement, assetPathMap: {
     source: string;
     target: string;
-}[], tagType?: 'link' | 'image') => void;
+}[], tagType?: 'link' | 'src') => void;

package/build/commands/web/internal/updateScriptTag.d.ts

@@ -1,5 +1,5 @@
 import { ServerType } from '@sasjs/utils';
-export declare const updateScriptTag: (tag: HTMLLinkElement, webSourcePathFull: string, destinationPath: string, serverType: ServerType, assetPathMap: {
+export declare const updateScriptTag: (tag: HTMLScriptElement, webSourcePathFull: string, destinationPath: string, serverType: ServerType, assetPathMap: {
     source: string;
     target: string;
 }[]) => Promise<void>;

package/build/commands/web/internal/updateScriptTag.js

@@ -45,28 +45,26 @@ var utils_1 = require("@sasjs/utils");
 var js_base64_1 = require("js-base64");
 var getWebServiceContent_1 = require("./getWebServiceContent");
 var updateScriptTag = function (tag, webSourcePathFull, destinationPath, serverType, assetPathMap) { return __awaiter(void 0, void 0, void 0, function () {
-    var scriptPath, isUrl, content_1, serviceContent;
+    var scriptPath, isUrl, _content, content, serviceContent, _content, content;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
                 scriptPath = tag.getAttribute('src');
-                isUrl = scriptPath && (scriptPath.startsWith('http') || scriptPath.startsWith('//'));
-                if (!scriptPath) return [3 /*break*/, 7];
+                if (!scriptPath) return [3 /*break*/, 8];
+                isUrl = scriptPath.startsWith('http') || scriptPath.startsWith('//');
                 if (!!isUrl) return [3 /*break*/, 7];
                 return [4 /*yield*/, (0, utils_1.readFile)(path_1.default.join(webSourcePathFull, scriptPath)).catch(function (_) {
                         throw new Error("Unable to find file: ".concat(scriptPath));
                     })];
             case 1:
-                content_1 = _a.sent();
-                assetPathMap.forEach(function (pathEntry) {
-                    content_1 = content_1.replace(new RegExp(pathEntry.source, 'g'), pathEntry.target);
-                });
+                _content = _a.sent();
+                content = modifyLinksInContent(_content, assetPathMap);
                 if (!(serverType === utils_1.ServerType.SasViya)) return [3 /*break*/, 3];
-                return [4 /*yield*/, (0, utils_1.createFile)(path_1.default.join(destinationPath, scriptPath), content_1)];
+                return [4 /*yield*/, (0, utils_1.createFile)(path_1.default.join(destinationPath, scriptPath), content)];
             case 2:
                 _a.sent();
                 return [3 /*break*/, 6];
-            case 3: return [4 /*yield*/, (0, getWebServiceContent_1.getWebServiceContent)((0, js_base64_1.encode)(content_1), 'JS', serverType)];
+            case 3: return [4 /*yield*/, (0, getWebServiceContent_1.getWebServiceContent)((0, js_base64_1.encode)(content), 'JS', serverType)];
             case 4:
                 serviceContent = _a.sent();
                 return [4 /*yield*/, (0, utils_1.createFile)(path_1.default.join(destinationPath, "".concat(scriptPath.replace(/\.js$/, '-js'), ".sas")), serviceContent)];
@@ -78,8 +76,21 @@ var updateScriptTag = function (tag, webSourcePathFull, destinationPath, serverT
                     return entry.source === scriptPath || "./".concat(entry.source) === scriptPath;
                 }).target);
                 _a.label = 7;
-            case 7: return [2 /*return*/];
+            case 7: return [3 /*break*/, 9];
+            case 8:
+                _content = tag.innerHTML;
+                content = modifyLinksInContent(_content, assetPathMap);
+                tag.innerHTML = content;
+                _a.label = 9;
+            case 9: return [2 /*return*/];
         }
     });
 }); };
 exports.updateScriptTag = updateScriptTag;
+var modifyLinksInContent = function (_content, assetPathMap) {
+    var content = _content;
+    assetPathMap.forEach(function (pathEntry) {
+        content = content.replace(new RegExp(pathEntry.source, 'g'), pathEntry.target);
+    });
+    return content;
+};

package/build/commands/web/internal/updateStyleTag.d.ts

@@ -0,0 +1,5 @@
+import { ServerType } from '@sasjs/utils';
+export declare const updateStyleTag: (tag: HTMLStyleElement | HTMLLinkElement, webSourcePathFull: string, destinationPath: string, serverType: ServerType, assetPathMap: {
+    source: string;
+    target: string;
+}[]) => Promise<void>;