@salesforce/core 4.2.2 → 4.3.1

package/README.md

@@ -23,6 +23,10 @@ See the [API documentation](https://forcedotcom.github.io/sfdx-core/).
 
 If you are interested in contributing, please take a look at the [CONTRIBUTING](CONTRIBUTING.md) guide.
 
+## Issues
+
+Please report all issues to [issues only repository](https://github.com/forcedotcom/cli/issues).
+
 # Using TestSetup
 
 The Salesforce DX Core Library provides a unit testing utility to help with mocking and sand-boxing core components. This feature allows unit tests to execute without needing to make API calls to salesforce.com.
@@ -220,3 +224,45 @@ describe('Testing log lines', () => {
   });
 });
 ```
+
+## Message Transformer
+
+the Messages class, by default, will load message text during run time. It's optimized to do this only per file.
+
+If you're using @salesforce/core or other code that uses its Messages class in a bundler (webpack, esbuild, etc) it may struggle with these runtime references.
+
+src/messageTransformer will "inline" the messages into the js files during TS compile using `https://github.com/cevek/ttypescript`.
+
+In your plugin or library,
+
+`yarn add --dev ttypescript`
+
+> tsconfig.json
+
+```json
+{
+  ...
+  "plugins": [{ "transform": "@salesforce/core/lib/messageTransformer", "import": "messageTransformer" }]
+}
+```
+
+> .sfdevrc.json, which gets merged into package.json
+
+```json
+"wireit": {
+    "compile": {
+      "command": "ttsc -p . --pretty --incremental",
+      "files": [
+        "src/**/*.ts",
+        "tsconfig.json",
+        "messages"
+      ],
+      "output": [
+        "lib/**",
+        "*.tsbuildinfo"
+      ],
+      "clean": "if-file-deleted"
+    }
+  }
+
+```

package/lib/messageTransformer.d.ts

@@ -0,0 +1,8 @@
+import * as ts from 'typescript';
+/**
+ *
+ * @experimental
+ * transforms `messages` references from dynamic run-time to static compile-time values
+ */
+export declare const messageTransformer: () => ts.TransformerFactory<ts.SourceFile>;
+export default messageTransformer;

package/lib/messageTransformer.js

@@ -0,0 +1,85 @@
+"use strict";
+/*
+ * Copyright (c) 2023, salesforce.com, inc.
+ * All rights reserved.
+ * Licensed under the BSD 3-Clause license.
+ * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.messageTransformer = void 0;
+const ts = require("typescript");
+const messages_1 = require("./messages");
+/**
+ *
+ * @experimental
+ * transforms `messages` references from dynamic run-time to static compile-time values
+ */
+const messageTransformer = () => {
+    messages_1.Messages.importMessagesDirectory(process.cwd());
+    const transformerFactory = (context) => (sourceFile) => {
+        if (
+        // if there are no messages, no transformation is needed
+        !sourceFile.statements.some((i) => ts.isImportDeclaration(i) && i.importClause?.getText().includes('Messages')) ||
+            // don't transform the transformer itself
+            sourceFile.fileName.includes('messageTransformer.ts')) {
+            return sourceFile;
+        }
+        const visitor = (node) => {
+            if (ts.isExpressionStatement(node) && node.getText().includes('importMessagesDirectory')) {
+                // importMessagesDirectory now happens at compile, not in runtime
+                // returning undefined removes the node
+                return undefined;
+            }
+            if (
+            // transform a runtime load call into hardcoded messages values
+            // const foo = Messages.load|loadMessages('pluginName', 'messagesFile' ...) =>
+            // const foo = new Messages('pluginName', 'messagesFile', new Map([['key', 'value']]))
+            ts.isCallExpression(node) &&
+                ts.isPropertyAccessExpression(node.expression) &&
+                node.expression.expression.getText() === 'Messages' &&
+                node.expression.name.getText().includes('load')) {
+                // we always want the first two arguments, which are the plugin name and the messages file name
+                const arrayMembers = node.arguments.slice(0, 2);
+                const arrayMembersText = arrayMembers.map(getTextWithoutQuotes);
+                // Messages doesn't care whether you call messages.load or loadMessages, it loads the whole file
+                const messagesInstance = messages_1.Messages.loadMessages(arrayMembersText[0], arrayMembersText[1]);
+                return context.factory.createNewExpression(node.expression.expression, undefined, [
+                    arrayMembers[0],
+                    arrayMembers[1],
+                    context.factory.createNewExpression(context.factory.createIdentifier('Map'), undefined, [
+                        messageMapToHardcodedMap(messagesInstance.messages),
+                    ]),
+                ]);
+            }
+            // it might be a node that contains one of the things we're interested in, so keep digging
+            return ts.visitEachChild(node, visitor, context);
+        };
+        return ts.visitNode(sourceFile, visitor);
+    };
+    return transformerFactory;
+};
+exports.messageTransformer = messageTransformer;
+exports.default = exports.messageTransformer;
+const getTextWithoutQuotes = (node) => node.getText().replace(/'/g, '');
+/** turn a loaded message map into  */
+const messageMapToHardcodedMap = (messages) => ts.factory.createArrayLiteralExpression(Array.from(messages).map(([key, value]) => {
+    // case 1: string
+    if (typeof value === 'string') {
+        return ts.factory.createArrayLiteralExpression([
+            ts.factory.createStringLiteral(key),
+            ts.factory.createStringLiteral(value),
+        ]);
+    }
+    else if (Array.isArray(value)) {
+        // case 2: string[]
+        return ts.factory.createArrayLiteralExpression([
+            ts.factory.createStringLiteral(key),
+            ts.factory.createArrayLiteralExpression(value.map((v) => ts.factory.createStringLiteral(v))),
+        ]);
+    }
+    else {
+        // turn the object into a map and recurse!
+        return messageMapToHardcodedMap(new Map(Object.entries(value)));
+    }
+}));
+//# sourceMappingURL=messageTransformer.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@salesforce/core",
-  "version": "4.2.2",
+  "version": "4.3.1",
   "description": "Core libraries to interact with SFDX projects, orgs, and APIs.",
   "main": "lib/exported",
   "types": "lib/exported.d.ts",
@@ -67,7 +67,7 @@
     "@types/proper-lockfile": "^4.1.2",
     "@types/shelljs": "0.8.12",
     "@typescript-eslint/eslint-plugin": "^5.59.9",
-    "@typescript-eslint/parser": "^5.59.7",
+    "@typescript-eslint/parser": "^5.59.9",
     "chai": "^4.3.7",
     "chai-string": "^1.5.0",
     "eslint": "^8.41.0",

package/messageTransformer/messageTransformer.ts

@@ -1,93 +0,0 @@
-/*
- * Copyright (c) 2023, salesforce.com, inc.
- * All rights reserved.
- * Licensed under the BSD 3-Clause license.
- * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
- */
-/* eslint-disable no-console */
-/* eslint-disable complexity */
-
-import * as ts from 'typescript';
-import { Messages, StoredMessageMap } from '../src/messages';
-
-/**
- *
- * @experimental
- * transforms `messages` references from dynamic run-time to static compile-time values
- */
-const transformer = (program: ts.Program, pluginOptions: {}) => {
-  Messages.importMessagesDirectory(process.cwd());
-  const transformerFactory: ts.TransformerFactory<ts.SourceFile> = (context) => {
-    return (sourceFile) => {
-      // if there are no messages, no transformation is needed
-      if (
-        !sourceFile.statements.some((i) => ts.isImportDeclaration(i) && i.importClause?.getText().includes('Messages'))
-      ) {
-        return sourceFile;
-      }
-
-      const visitor = (node: ts.Node): ts.VisitResult<ts.Node> => {
-        if (ts.isExpressionStatement(node) && node.getText().includes('importMessagesDirectory')) {
-          // importMessagesDirectory now happens at compile, not in runtime
-          // returning undefined removes the node
-          return undefined;
-        }
-        if (
-          // transform a runtime load call into hardcoded messages values
-          // const foo = Messages.load|loadMessages('pluginName', 'messagesFile' ...) =>
-          // const foo = new Messages('pluginName', 'messagesFile', new Map([['key', 'value']]))
-          ts.isCallExpression(node) &&
-          ts.isPropertyAccessExpression(node.expression) &&
-          node.expression.expression.getText() === 'Messages' &&
-          node.expression.name.getText().includes('load')
-        ) {
-          // we always want the first two arguments, which are the plugin name and the messages file name
-          const arrayMembers = node.arguments.slice(0, 2);
-          const arrayMembersText = arrayMembers.map(getTextWithoutQuotes);
-
-          // Messages doesn't care whether you call messages.load or loadMessages, it loads the whole file
-          const messagesInstance = Messages.loadMessages(arrayMembersText[0], arrayMembersText[1]);
-          return context.factory.createNewExpression(node.expression.expression, undefined, [
-            arrayMembers[0],
-            arrayMembers[1],
-            context.factory.createNewExpression(context.factory.createIdentifier('Map'), undefined, [
-              messageMapToHardcodedMap(messagesInstance.messages),
-            ]),
-          ]);
-        }
-        // it might be a node that contains one of the things we're interested in, so keep digging
-        return ts.visitEachChild(node, visitor, context);
-      };
-      return ts.visitNode(sourceFile, visitor);
-    };
-  };
-  return transformerFactory;
-};
-
-export default transformer;
-
-const getTextWithoutQuotes = (node: ts.Node): string => node.getText().replace(/'/g, '');
-
-/** turn a loaded message map into  */
-const messageMapToHardcodedMap = (messages: StoredMessageMap): ts.ArrayLiteralExpression => {
-  return ts.factory.createArrayLiteralExpression(
-    Array.from(messages).map(([key, value]) => {
-      // case 1: string
-      if (typeof value === 'string') {
-        return ts.factory.createArrayLiteralExpression([
-          ts.factory.createStringLiteral(key),
-          ts.factory.createStringLiteral(value),
-        ]);
-      } else if (Array.isArray(value)) {
-        // case 2: string[]
-        return ts.factory.createArrayLiteralExpression([
-          ts.factory.createStringLiteral(key),
-          ts.factory.createArrayLiteralExpression(value.map((v) => ts.factory.createStringLiteral(v))),
-        ]);
-      } else {
-        // turn the object into a map and recurse!
-        return messageMapToHardcodedMap(new Map(Object.entries(value)));
-      }
-    })
-  );
-};