[Package Importer] Embedded Host

lib/index.mjs

@@ -4,6 +4,7 @@ export const compile = sass.compile;
 export const compileAsync = sass.compileAsync;
 export const compileString = sass.compileString;
 export const compileStringAsync = sass.compileStringAsync;
+export const nodePackageImporter = sass.nodePackageImporter;
 export const Logger = sass.Logger;
 export const CalculationInterpolation = sass.CalculationInterpolation
 export const CalculationOperation = sass.CalculationOperation
@@ -60,6 +61,10 @@ export default {
     defaultExportDeprecation();
     return sass.compileStringAsync;
   },
+  get nodePackageImporter() {
+    defaultExportDeprecation();
+    return sass.nodePackageImporter;
+  },
   get Logger() {
     defaultExportDeprecation();
     return sass.Logger;

lib/index.ts

@@ -31,6 +31,7 @@ export {
   compileString,
   compileAsync,
   compileStringAsync,
+  nodePackageImporter,
 } from './src/compile';
 export {render, renderSync} from './src/legacy';
 

lib/src/compile.ts

@@ -24,6 +24,8 @@ import {
   legacyImporterProtocol,
 } from './legacy/utils';
 
+export {nodePackageImporter} from './importer-registry';
+
 /// Allow the legacy API to pass in an option signaling to the modern API that
 /// it's being run in legacy mode.
 ///

lib/src/importer-registry.ts

@@ -7,10 +7,19 @@ import {URL} from 'url';
 import {inspect} from 'util';
 
 import * as utils from './utils';
-import {FileImporter, Importer, Options} from './vendor/sass';
+import {
+  FileImporter,
+  Importer,
+  NodePackageImporter,
+  Options,
+} from './vendor/sass';
 import * as proto from './vendor/embedded_sass_pb';
 import {catchOr, thenOr, PromiseOr} from './utils';
 
+export const nodePackageImporter: NodePackageImporter = {
+  _NodePackageImporterBrand: '',
+};
+
 /**
  * A registry of importers defined in the host that can be invoked by the
  * compiler.
@@ -41,12 +50,37 @@ export class ImporterRegistry<sync extends 'sync' | 'async'> {
       );
   }
 
+  // Type predicate for NodePackageImporter
+  isNodePackageImporter(
+    importer: Importer<sync> | FileImporter<sync> | NodePackageImporter
+  ): importer is NodePackageImporter {
+    return (
+      (importer as NodePackageImporter)._NodePackageImporterBrand !== undefined
+    );
+  }
+
   /** Converts an importer to a proto without adding it to `this.importers`. */
   register(
-    importer: Importer<sync> | FileImporter<sync>
+    importer: Importer<sync> | FileImporter<sync> | NodePackageImporter
   ): proto.InboundMessage_CompileRequest_Importer {
     const message = new proto.InboundMessage_CompileRequest_Importer();
-    if ('canonicalize' in importer) {
+    if (this.isNodePackageImporter(importer)) {
+      if (importer !== nodePackageImporter) {
+        throw 'Incorrect Node Package Importer used';
+      }
+      const importerMessage = new proto.NodePackageImporter();
+      const entryPointURL = require.main?.filename;
+      if (!entryPointURL) {
+        throw new Error(
+          'Node Package Importer requires access to a filesystem.'
+        );
+      }
+      importerMessage.entryPointUrl = entryPointURL;
+      message.importer = {
+        case: 'nodePackageImporter',
+        value: importerMessage,
+      };
+    } else if ('canonicalize' in importer) {
       if ('findFileUrl' in importer) {
         throw new Error(
           'Importer may not contain both canonicalize() and findFileUrl(): ' +

lib/src/legacy/index.ts

@@ -5,6 +5,7 @@
 import * as fs from 'fs';
 import * as p from 'path';
 import {pathToFileURL, URL} from 'url';
+import {nodePackageImporter} from '../importer-registry';
 
 import {Exception} from '../exception';
 import {
@@ -31,6 +32,8 @@ import {
   LegacyStringOptions,
   Options,
   StringOptions,
+  Importer,
+  FileImporter,
 } from '../vendor/sass';
 import {wrapFunction} from './value/wrap';
 import {endOfLoadProtocol, LegacyImporterWrapper} from './importer';
@@ -140,21 +143,28 @@ function convertOptions<sync extends 'sync' | 'async'>(
     functions[signature.trimLeft()] = wrapFunction(self, callback, sync);
   }
 
-  const importers =
+  let importers;
+  if (
     options.importer &&
     (!(options.importer instanceof Array) || options.importer.length > 0)
-      ? [
-          new LegacyImporterWrapper(
-            self,
-            options.importer instanceof Array
-              ? options.importer
-              : [options.importer],
-            options.includePaths ?? [],
-            options.file ?? 'stdin',
-            sync
-          ),
-        ]
-      : undefined;
+  ) {
+    importers = [
+      new LegacyImporterWrapper(
+        self,
+        options.importer instanceof Array
+          ? options.importer
+          : [options.importer],
+        options.includePaths ?? [],
+        options.file ?? 'stdin',
+        sync
+      ),
+    ];
+  }
+  if (options.pkgImporter === 'node') {
+    importers = importers
+      ? [nodePackageImporter, ...importers]
+      : [nodePackageImporter];
+  }
 
   return {
     functions,
@@ -178,14 +188,20 @@ function convertStringOptions<sync extends 'sync' | 'async'>(
 ): StringOptions<sync> & {legacy: true} {
   const modernOptions = convertOptions(options, sync);
 
+  // Find the first non-nodePackageImporter to pass as legacy `importer` option.
+  // nodePackageImporter will be passed in `modrenOptions.importers`.
+  const importer = modernOptions.importers?.find(
+    _importer => _importer !== nodePackageImporter
+  ) as Importer<sync> | FileImporter<sync>;
+
   return {
     ...modernOptions,
     url: options.file
       ? options.importer
         ? pathToLegacyFileUrl(options.file)
         : pathToFileURL(options.file)
       : new URL(legacyImporterProtocol),
-    importer: modernOptions.importers ? modernOptions.importers[0] : undefined,
+    importer,
     syntax: options.indentedSyntax ? 'indented' : 'scss',
   };
 }