@pronto-tools-and-more/sass-compiler 3.3.8

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@pronto-tools-and-more/sass-compiler",
+  "version": "3.3.8",
+  "description": "",
+  "main": "src/sassCompilerMain.js",
+  "type": "module",
+  "scripts": {
+    "test": "node --unhandled-rejections=warn --experimental-vm-modules ./node_modules/jest/bin/jest.js --detectOpenHandles --forceExit",
+    "test:watch": "node --unhandled-rejections=warn --experimental-vm-modules ./node_modules/jest/bin/jest.js --watch",
+    "type-check": "tsc"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@lvce-editor/assert": "^1.2.0",
+    "@lvce-editor/ipc": "^9.1.0",
+    "@lvce-editor/json-rpc": "^1.3.0",
+    "@lvce-editor/verror": "^1.3.0",
+    "sass": "^1.77.2"
+  },
+  "devDependencies": {
+    "@types/node": "^20.12.7",
+    "jest": "^29.7.0"
+  },
+  "jest": {
+    "injectGlobals": false
+  }
+}

package/src/parts/Assert/Assert.js

@@ -0,0 +1 @@
+export * from "@lvce-editor/assert";

package/src/parts/Callback/Callback.js

@@ -0,0 +1 @@
+export { resolve } from "@lvce-editor/json-rpc";

package/src/parts/Command/Command.js

@@ -0,0 +1,9 @@
+import * as CommandState from "../CommandState/CommandState.js";
+
+export const execute = (command, ...args) => {
+  const fn = CommandState.getCommand(command);
+  if (!fn) {
+    throw new Error(`Command not found ${command}`);
+  }
+  return fn(...args);
+};

package/src/parts/CommandMap/CommandMap.js

@@ -0,0 +1,10 @@
+import * as CompileSass from "../CompileSass/CompileSass.js";
+import * as CompileSassIndividually from "../CompileSassIndividually/CompileSassIndividually.js";
+import * as InMemoryFileState from "../InMemoryFileState/InMemoryFileState.js";
+
+export const commandMap = {
+  "CompileSass.compileSass": CompileSass.compileSass,
+  "CompileSass.compileSassIndividually":
+    CompileSassIndividually.compileSassIndividually,
+  "CompileSass.set": InMemoryFileState.set,
+};

package/src/parts/CommandState/CommandState.js

@@ -0,0 +1,17 @@
+export const state = {
+  commands: Object.create(null),
+};
+
+export const registerCommand = (key, fn) => {
+  state.commands[key] = fn;
+};
+
+export const registerCommands = (commandMap) => {
+  for (const [key, value] of Object.entries(commandMap)) {
+    registerCommand(key, value);
+  }
+};
+
+export const getCommand = (key) => {
+  return state.commands[key];
+};

package/src/parts/CompileSass/CompileSass.js

@@ -0,0 +1,51 @@
+import { VError } from "@lvce-editor/verror";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import * as sass from "sass";
+import * as Assert from "../Assert/Assert.js";
+import * as GetContent from "../GetContent/GetContent.js";
+import * as UpdateCss from "../UpdateCss/UpdateCss.js";
+
+export const compileSass = async ({
+  absolutePath = "",
+  updateDynamicResources = true,
+  sourceMap = false,
+} = {}) => {
+  try {
+    Assert.string(absolutePath);
+    const content = GetContent.getContent(absolutePath);
+    const result = sass.compileString(content, {
+      url: pathToFileURL(absolutePath),
+      importers: [
+        {
+          canonicalize(url) {
+            return new URL(url);
+          },
+          load(canonicalUrl) {
+            const path = fileURLToPath(canonicalUrl);
+            const content = GetContent.getContent(path);
+            return {
+              contents: content,
+              syntax: "scss",
+            };
+          },
+        },
+      ],
+      sourceMap,
+    });
+    let css = result.css;
+    if (updateDynamicResources) {
+      const updated = UpdateCss.updateCss(css);
+      return {
+        css: updated,
+        sourceMap: result.sourceMap,
+      };
+    }
+    const reverse = UpdateCss.reverseUpdateCss(css);
+    return {
+      css: reverse,
+      sourceMap: result.sourceMap,
+    };
+  } catch (error) {
+    throw new VError(error, `Failed to compile sass`);
+  }
+};

package/src/parts/CompileSassIndividually/CompileSassIndividually.js

@@ -0,0 +1,82 @@
+import { VError } from "@lvce-editor/verror";
+import { readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import * as Assert from "../Assert/Assert.js";
+import * as CompileSass from "../CompileSass/CompileSass.js";
+import * as InMemoryFileState from "../InMemoryFileState/InMemoryFileState.js";
+
+const getIndividualFileNames = (contents) => {
+  const lines = contents.split("\n");
+  const individualFileNames = [];
+  for (const line of lines) {
+    if (line && line.startsWith("@import")) {
+      const match = line.slice('@import "./'.length, -2);
+      if (match.endsWith(".scss")) {
+        individualFileNames.push(match);
+      } else {
+        individualFileNames.push(match + ".scss");
+      }
+    }
+  }
+  return individualFileNames;
+};
+
+const getFileNamesToUpdate = (
+  individualFileNames,
+  rootScssFileName,
+  fileName,
+  needsFull
+) => {
+  if (needsFull || !fileName) {
+    return individualFileNames;
+  }
+  // console.log({ individualFileNames, fileName });
+  for (const individualFileName of individualFileNames) {
+    const absolutePath = join(dirname(rootScssFileName), individualFileName);
+    if (absolutePath === fileName) {
+      return [individualFileName];
+    }
+  }
+  console.info(`[pronto] no matching scss file found for ${fileName}`);
+  return [];
+};
+
+export const compileSassIndividually = async (
+  rootScssFileName,
+  {
+    updateDynamicResources = true,
+    fileName = "",
+    needsFull = true,
+    content = undefined,
+  } = {}
+) => {
+  try {
+    Assert.string(rootScssFileName);
+    if (fileName && content) {
+      InMemoryFileState.set(fileName, content);
+    }
+    const contents = await readFile(rootScssFileName, "utf8");
+    const individualFileNames = getIndividualFileNames(contents);
+    const toUpdate = getFileNamesToUpdate(
+      individualFileNames,
+      rootScssFileName,
+      fileName,
+      needsFull
+    );
+    const results = [];
+    for (const fileName of toUpdate) {
+      const absolutePath = join(dirname(rootScssFileName), fileName);
+      const result = await CompileSass.compileSass({
+        updateDynamicResources,
+        absolutePath,
+      });
+      results.push({
+        fileName,
+        css: result.css,
+      });
+    }
+    return results;
+  } catch (error) {
+    throw new VError(error, `Failed to compile sass`);
+  }
+};

package/src/parts/GetContent/GetContent.js

@@ -0,0 +1,10 @@
+import { readFileSync } from "node:fs";
+import * as InMemoryFileState from "../InMemoryFileState/InMemoryFileState.js";
+
+export const getContent = (uri) => {
+  const memoryResult = InMemoryFileState.get(uri);
+  if (memoryResult) {
+    return memoryResult;
+  }
+  return readFileSync(uri, "utf8");
+};

package/src/parts/HandleIpc/HandleIpc.js

@@ -0,0 +1,10 @@
+import * as HandleMessage from "../HandleMessage/HandleMessage.js";
+
+export const handleIpc = (ipc) => {
+  if ("addEventListener" in ipc) {
+    ipc.addEventListener("message", HandleMessage.handleMessage);
+  } else if ("on" in ipc) {
+    // deprecated
+    ipc.on("message", HandleMessage.handleMessage);
+  }
+};

package/src/parts/HandleMessage/HandleMessage.js

@@ -0,0 +1,27 @@
+import * as Callback from "../Callback/Callback.js";
+import * as Command from "../Command/Command.js";
+import * as JsonRpc from "../JsonRpc/JsonRpc.js";
+
+const prepare = (error) => {
+  return error;
+};
+
+const requiresSocket = (method) => {
+  return false;
+};
+
+const logError = (error, prettyError) => {
+  console.error(error);
+};
+
+export const handleMessage = (event) => {
+  return JsonRpc.handleJsonRpcMessage(
+    event.target,
+    event.data,
+    Command.execute,
+    Callback.resolve,
+    prepare,
+    logError,
+    requiresSocket,
+  );
+};

package/src/parts/InMemoryFileState/InMemoryFileState.js

@@ -0,0 +1,11 @@
+const state = {
+  files: Object.create(null),
+};
+
+export const set = (uri, content) => {
+  state.files[uri] = content;
+};
+
+export const get = (uri) => {
+  return state.files[uri];
+};

package/src/parts/IpcChild/IpcChild.js

@@ -0,0 +1,15 @@
+import * as IpcChildModule from "../IpcChildModule/IpcChildModule.js";
+
+export const listen = async ({ method, ...params }) => {
+  const module = await IpcChildModule.getModule(method);
+  // @ts-ignore
+  const rawIpc = await module.listen(params);
+  // @ts-ignore
+  if (module.signal) {
+    // @ts-ignore
+    module.signal(rawIpc);
+  }
+  // @ts-ignore
+  const ipc = module.wrap(rawIpc);
+  return ipc;
+};

package/src/parts/IpcChildModule/IpcChildModule.js

@@ -0,0 +1,25 @@
+import {
+  IpcChildWithElectronMessagePort,
+  IpcChildWithElectronUtilityProcess,
+  IpcChildWithNodeForkedProcess,
+  IpcChildWithNodeWorker,
+  IpcChildWithWebSocket,
+} from "@lvce-editor/ipc";
+import * as IpcChildType from "../IpcChildType/IpcChildType.js";
+
+export const getModule = (method) => {
+  switch (method) {
+    case IpcChildType.NodeForkedProcess:
+      return IpcChildWithNodeForkedProcess;
+    case IpcChildType.NodeWorker:
+      return IpcChildWithNodeWorker;
+    case IpcChildType.ElectronUtilityProcess:
+      return IpcChildWithElectronUtilityProcess;
+    case IpcChildType.ElectronMessagePort:
+      return IpcChildWithElectronMessagePort;
+    case IpcChildType.WebSocket:
+      return IpcChildWithWebSocket;
+    default:
+      throw new Error("unexpected ipc type");
+  }
+};

package/src/parts/IpcChildType/IpcChildType.js

@@ -0,0 +1,20 @@
+export const NodeWorker = 1;
+export const NodeForkedProcess = 2;
+export const ElectronUtilityProcess = 3;
+export const ElectronMessagePort = 4;
+export const NodeMessagePort = 5;
+export const WebSocket = 6;
+
+export const Auto = () => {
+  const { argv } = process;
+  if (argv.includes("--ipc-type=node-worker")) {
+    return NodeWorker;
+  }
+  if (argv.includes("--ipc-type=node-forked-process")) {
+    return NodeForkedProcess;
+  }
+  if (argv.includes("--ipc-type=electron-utility-process")) {
+    return ElectronUtilityProcess;
+  }
+  throw new Error(`[shared-process] unknown ipc type`);
+};

package/src/parts/IpcId/IpcId.js

@@ -0,0 +1,9 @@
+export const EmbedsProcess = 2;
+export const EmbedsWorker = 77;
+export const ExtensionHostHelperProcess = 3;
+export const MainProcess = -5;
+export const ProcessExplorer = 11;
+export const SearchProcess = 13;
+export const SharedProcess = 1;
+export const TerminalProcess = 7;
+export const Unknown = 0;

package/src/parts/JsonRpc/JsonRpc.js

@@ -0,0 +1 @@
+export * from "@lvce-editor/json-rpc";

package/src/parts/Listen/Listen.js

@@ -0,0 +1,8 @@
+import * as HandleIpc from "../HandleIpc/HandleIpc.js";
+import * as IpcChild from "../IpcChild/IpcChild.js";
+import * as IpcChildType from "../IpcChildType/IpcChildType.js";
+
+export const listen = async () => {
+  const ipc = await IpcChild.listen({ method: IpcChildType.Auto() });
+  HandleIpc.handleIpc(ipc);
+};

package/src/parts/Main/Main.js

@@ -0,0 +1,8 @@
+import * as CommandMap from "../CommandMap/CommandMap.js";
+import * as CommandState from "../CommandState/CommandState.js";
+import * as Listen from "../Listen/Listen.js";
+
+export const main = async () => {
+  CommandState.registerCommands(CommandMap.commandMap);
+  await Listen.listen();
+};

package/src/parts/UpdateCss/UpdateCss.js

@@ -0,0 +1,17 @@
+const occurrenceSnippet = "resource://dynamic";
+const replacementSnippet = ``;
+
+export const updateCss = (content) => {
+  return content.replaceAll(occurrenceSnippet, replacementSnippet);
+};
+
+const reverseOccurrenceSnippet = "../../images";
+
+const reverseReplacementSnippet = "resource://dynamic/storefront/images";
+
+export const reverseUpdateCss = (content) => {
+  return content.replaceAll(
+    reverseOccurrenceSnippet,
+    reverseReplacementSnippet
+  );
+};

package/src/sassCompilerMain.js

@@ -0,0 +1,3 @@
+import * as Main from "./parts/Main/Main.js";
+
+Main.main();