ember-scoped-css 0.19.1 → 0.21.0

package/README.md

@@ -52,15 +52,13 @@ Note that supporting `pods` is _opt in_, because all apps can have their pods ro
 ## Installation for an embroider app
 
 ```bash 
-npm install --save-dev ember-scoped-css
+npm install --save-dev ember-scoped-css ember-scoped-css-compat
 ```
 
 Setup webpack:
 ```js 
 // ember-cli-build.js
-module.exports = async function (defaults) {
-  const { appJsUnplugin } = await import('ember-scoped-css/build');
-  
+module.exports = async function (defaults) {  
   const app = new EmberApp(defaults, { /* ... */ });
 
   const { Webpack } = require('@embroider/webpack');
@@ -68,12 +66,10 @@ module.exports = async function (defaults) {
   return require('@embroider/compat').compatBuild(app, Webpack, {
     /* ... */
     packagerOptions: {
-      // css loaders for live reloading css
       webpackConfig: {
-        plugins: [appJsUnplugin.webpack({ appDir: __dirname })],
         module: {
           rules: [
-            // css loaders for production
+            // css loaders for your app CSS
             {
               test: /\.css$/,
               use: [
@@ -87,17 +83,6 @@ module.exports = async function (defaults) {
                 },
               ],
             },
-            {
-              test: /(\.hbs)|(\.js)$/,
-              use: [
-                {
-                  loader: require.resolve(
-                    'ember-scoped-css/build/app-dependency-loader'
-                  ),
-                },
-              ],
-              exclude: [/node_modules/, /dist/, /assets/],
-            },
           ],
         },
       },

package/classic-app-support/helpers/scoped-class.js

@@ -0,0 +1 @@
+export { scopedClass as default } from 'ember-scoped-css';

package/declarations/lib/path/utils.d.ts

@@ -62,10 +62,13 @@ export function withoutExtension(filePath: string): string;
  *   - URL-absolute path, starting with /
  *
  * @param {string} fileName
- * @param {string[]} [additionalRoots]
+ * @param {{ additionalRoots?: string[]; cwd: string }} options
  * @returns
  */
-export function isRelevantFile(fileName: string, additionalRoots?: string[] | undefined): boolean | undefined;
+export function isRelevantFile(fileName: string, { additionalRoots, cwd }: {
+    additionalRoots?: string[];
+    cwd: string;
+}): boolean | undefined;
 export function packageScopedPathToModulePath(packageScopedPath: any): string;
 /**
  * returns the app-module path of the source file
@@ -75,10 +78,6 @@ export function packageScopedPathToModulePath(packageScopedPath: any): string;
  * which is `<package.json#name>/path-to-file`
  */
 export function appPath(sourcePath: any): string;
-/**
- * Populates the "seen" workspace cache,
- * so that we don't hit the file system too often.
- */
 export function findWorkspacePath(sourcePath: any): any;
 export { hashFromAbsolutePath } from "./hash-from-absolute-path.js";
 export { hashFromModulePath } from "./hash-from-module-path.js";

package/declarations/lib/path/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/lib/path/utils.js"],"names":[],"mappings":"AAWA;;;;;;GAMG;AACH,mCAHW,MAAM,UAShB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qCAHW,MAAM,GACJ,MAAM,CAalB;AAED;;;;;GAKG;AACH,wCAFW,MAAM,WAQhB;AAED;;;;;;;;;;GAUG;AACH,gCAFW,MAAM,WAYhB;AAED;;;;GAIG;AACH,2CAHW,MAAM,UAOhB;AAMD;;;;;;;;;GASG;AACH,yCAJW,MAAM,+DAiEhB;AAED,8EAsCC;AAED;;;;;;GAMG;AACH,iDA4BC;AAoBD;;;GAGG;AACH,wDAgBC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/lib/path/utils.js"],"names":[],"mappings":"AAmBA;;;;;;GAMG;AACH,mCAHW,MAAM,UAShB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qCAHW,MAAM,GACJ,MAAM,CAalB;AAED;;;;;GAKG;AACH,wCAFW,MAAM,WAQhB;AAED;;;;;;;;;;GAUG;AACH,gCAFW,MAAM,WAYhB;AAED;;;;GAIG;AACH,2CAHW,MAAM,UAOhB;AAED;;;;;;;;;GASG;AACH,yCAJW,MAAM,4BACN;IAAE,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,uBA8DrD;AAED,8EAsCC;AAED;;;;;;GAMG;AACH,iDA4BC;AAED,wDAwBC"}

package/dist/cjs/app-css-loader.cjs

@@ -37,6 +37,7 @@ var import_node_fs2 = require("node:fs");
 var import_node_path2 = __toESM(require("node:path"), 1);
 
 // src/lib/path/utils.js
+var import_node_assert = __toESM(require("node:assert"), 1);
 var import_node_fs = __toESM(require("node:fs"), 1);
 var import_node_path = __toESM(require("node:path"), 1);
 var import_find_up = __toESM(require("find-up"), 1);
@@ -56,6 +57,12 @@ function hashFromAbsolutePath(absolutePath) {
 }
 
 // src/lib/path/utils.js
+var EMBROIDER_DIR = "node_modules/.embroider";
+var EMBROIDER_3_REWRITTEN_APP_PATH = `${EMBROIDER_DIR}/rewritten-app`;
+var EMBROIDER_3_REWRITTEN_APP_ASSETS = `${EMBROIDER_3_REWRITTEN_APP_PATH}/assets`;
+var EMBROIDER_3_REWRITTEN_PACKAGES = `${EMBROIDER_DIR}/rewritten-packages`;
+var IRRELEVANT_PATHS = ["node_modules/.pnpm"];
+var UNSUPPORTED_DIRECTORIES = /* @__PURE__ */ new Set(["tests"]);
 function hashFrom(filePath) {
   if (filePath.startsWith("/")) {
     return hashFromAbsolutePath(filePath);
@@ -77,6 +84,40 @@ function isPod(filePath) {
   }
   return filePath.endsWith("styles.css");
 }
+function isRelevantFile(fileName, { additionalRoots, cwd }) {
+  if (fileName.startsWith("/@embroider")) return false;
+  if (IRRELEVANT_PATHS.some((i) => fileName.includes(i))) return false;
+  if (fileName.includes("/node_modules/")) {
+    if (!fileName.includes(EMBROIDER_DIR)) {
+      return false;
+    }
+    if (fileName.includes(EMBROIDER_3_REWRITTEN_PACKAGES)) {
+      return false;
+    }
+    if (fileName.includes(EMBROIDER_3_REWRITTEN_APP_ASSETS)) {
+      if (fileName.endsWith(`${EMBROIDER_3_REWRITTEN_APP_ASSETS}/tests.js`)) {
+        return false;
+      }
+      return false;
+    }
+  }
+  let workspace = findWorkspacePath(fileName);
+  (0, import_node_assert.default)(cwd, `cwd was not passed to isRelevantFile`);
+  let ourWorkspace = findWorkspacePath(cwd);
+  if (workspace !== ourWorkspace) {
+    return false;
+  }
+  let local = fileName.replace(workspace, "");
+  let [, ...parts] = local.split("/").filter(Boolean);
+  if (UNSUPPORTED_DIRECTORIES.has(parts[0])) {
+    return false;
+  }
+  let roots = ["/components/", "/templates/", ...additionalRoots || []];
+  if (!roots.some((root) => fileName.includes(root))) {
+    return;
+  }
+  return true;
+}
 function packageScopedPathToModulePath(packageScopedPath) {
   let packageRelative = packageScopedPath.replace(/^\/src\//, "/");
   let parsed = import_node_path.default.parse(packageRelative);
@@ -92,31 +133,28 @@ function appPath(sourcePath) {
   let packageRelative = sourcePath.replace(workspacePath, "");
   packageRelative = packageRelative.replace(`/app/`, `/`);
   packageRelative = packageRelative.replace(
-    `/node_modules/.embroider/rewritten-app/`,
+    `${EMBROIDER_3_REWRITTEN_APP_PATH}/`,
     "/"
   );
   let localPackagerStylePath = packageScopedPathToModulePath(packageRelative);
   return `${name}${localPackagerStylePath}`;
 }
-var CACHE = /* @__PURE__ */ new Set();
-function hasSeen(sourcePath) {
-  for (let entry of CACHE) {
-    if (sourcePath.startsWith(entry)) {
-      return entry;
-    }
-  }
-  return;
-}
 function findWorkspacePath(sourcePath) {
-  let seen = hasSeen(sourcePath);
-  if (seen) {
-    return seen;
+  if (sourcePath.includes(EMBROIDER_3_REWRITTEN_APP_PATH)) {
+    sourcePath = sourcePath.split(EMBROIDER_3_REWRITTEN_APP_PATH)[0];
+  }
+  if (sourcePath.endsWith("/")) {
+    sourcePath = sourcePath.replace(/\/$/, "");
+  }
+  let candidatePath = import_node_path.default.join(sourcePath, "package.json");
+  const isWorkspace = import_node_fs.default.existsSync(candidatePath);
+  if (isWorkspace) {
+    return sourcePath;
   }
   const packageJsonPath = import_find_up.default.sync("package.json", {
     cwd: import_node_path.default.dirname(sourcePath)
   });
   const workspacePath = import_node_path.default.dirname(packageJsonPath);
-  CACHE.add(workspacePath);
   return workspacePath;
 }
 var MANIFEST_CACHE = /* @__PURE__ */ new Map();
@@ -197,6 +235,9 @@ ${rewrittenCss}
 async function app_css_loader_default(code) {
   const options = this.getOptions();
   const cssPath = this.resourcePath;
+  if (!isRelevantFile(cssPath, { ...options, cwd: this.rootContext })) {
+    return code;
+  }
   if (!cssPath.startsWith(this.rootContext)) {
     return code;
   }
@@ -217,4 +258,4 @@ async function app_css_loader_default(code) {
   }
   return code;
 }
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/build/app-css-loader.js", "../../src/lib/path/utils.js", "../../src/lib/path/hash-from-module-path.js", "../../src/lib/path/hash-from-absolute-path.js", "../../src/lib/rewriteCss.js", "../../src/lib/isInsideGlobal.js"],
  "sourcesContent": ["// import { createUnplugin }  from 'unplugin';\nimport { existsSync } from 'node:fs';\nimport path from 'node:path';\n\nimport { hashFrom } from '../lib/path/utils.js';\nimport rewriteCss from '../lib/rewriteCss.js';\n\nexport default async function (code) {\n  const options = this.getOptions();\n  const cssPath = this.resourcePath;\n\n  if (!cssPath.startsWith(this.rootContext)) {\n    return code;\n  }\n\n  const cssFileName = path.basename(cssPath);\n\n  const hbsPath = cssPath.replace('.css', '.hbs');\n  const gjsPath = cssPath.replace('.css', '.js');\n  const hbsExists = existsSync(hbsPath);\n  const gjsExists = existsSync(gjsPath);\n\n  if (hbsExists || gjsExists) {\n    const postfix = hashFrom(cssPath);\n    const rewrittenCss = rewriteCss(\n      code,\n      postfix,\n      cssFileName,\n      options.layerName,\n    );\n\n    return rewrittenCss;\n  }\n\n  return code;\n}\n", "import fsSync from 'node:fs';\nimport path from 'node:path';\n\nimport findUp from 'find-up';\n\nimport { hashFromAbsolutePath } from './hash-from-absolute-path.js';\nimport { hashFromModulePath } from './hash-from-module-path.js';\n\nexport { hashFromAbsolutePath } from './hash-from-absolute-path.js';\nexport { hashFromModulePath } from './hash-from-module-path.js';\n\n/**\n * Regardless of what the filePath format is,\n * this will try to return the correct postfix.\n *\n * @param {string} filePath\n * @returns\n */\nexport function hashFrom(filePath) {\n  if (filePath.startsWith('/')) {\n    return hashFromAbsolutePath(filePath);\n  }\n\n  return hashFromModulePath(filePath);\n}\n\n/**\n * Based on ember's component location conventions,\n * this function will provide a path for where we\n * expect the CSS to live.\n *\n * For co-located structure:\n *   - components/my-component.hbs\n *   - components/my-component.css\n *\n * For nested co-located structure\n *   - components/my-component/foo.hbs\n *   - components/my-component/foo.css\n *\n * For Pods routes structure\n *   - routes/my-route/template.{hbs,js}\n *   - routes/my-route/styles.css\n *\n * Deliberately not supported:\n *   - components w/ pods -- this is deprecated in 5.10\n *\n * @param {string} fileName - the hbs, js, gjs, gts or whatever co-located path.\n * @returns {string} - expected css path\n */\nexport function cssPathFor(fileName) {\n  let withoutExt = withoutExtension(fileName);\n  let cssPath = withoutExt + '.css';\n\n  if (isPod(fileName)) {\n    cssPath = fileName\n      .replace(/template\\.js$/, 'styles.css')\n      .replace(/template\\.hbs/, 'styles.css');\n  }\n\n  return cssPath;\n}\n\n/**\n * Note that components in the \"pods\" convention will\n * never be supported.\n *\n * @param {string} filePath\n */\nexport function isPodTemplate(filePath) {\n  if (filePath.includes('/components/')) {\n    return false;\n  }\n\n  return filePath.endsWith('template.js') || filePath.endsWith('template.hbs');\n}\n\n/**\n * Note that components in the \"pods\" convention will\n * never be supported.\n *\n * Checks if a file ends with\n * - template.js\n * - template.hbs\n * - styles.css\n *\n * @param {string} filePath\n */\nexport function isPod(filePath) {\n  if (filePath.includes('/components/')) {\n    return false;\n  }\n\n  if (isPodTemplate(filePath)) {\n    return true;\n  }\n\n  return filePath.endsWith('styles.css');\n}\n\n/**\n *\n * @param {string} filePath\n * @returns the same path, but without the extension\n */\nexport function withoutExtension(filePath) {\n  let parsed = path.parse(filePath);\n\n  return path.join(parsed.dir, parsed.name);\n}\n\nconst IRRELEVANT_PATHS = ['node_modules/.pnpm'];\n\nconst UNSUPPORTED_DIRECTORIES = new Set(['tests']);\n\n/**\n * Examples for fileName\n * - absolute on-disk path\n * - in webpack\n *   - URL-absolute path, starting with /\n *\n * @param {string} fileName\n * @param {string[]} [additionalRoots]\n * @returns\n */\nexport function isRelevantFile(fileName, additionalRoots) {\n  if (fileName.startsWith('/@embroider')) return false;\n  if (IRRELEVANT_PATHS.some((i) => fileName.includes(i))) return false;\n\n  if (fileName.includes('/node_modules/')) {\n    // if a file is not the embroider cache directory\n    // and is in node_modules, skip it.\n    if (!fileName.includes('/node_modules/.embroider/')) {\n      return false;\n    }\n\n    // rewritten packages should have already been processed at their own\n    // publish time\n    if (fileName.includes('/node_modules/.embroider/rewritten-packages/')) {\n      return false;\n    }\n\n    // These are already the bundled files.\n    if (fileName.includes('/node_modules/.embroider/rewritten-app/assets/')) {\n      // not supported, never will be\n      if (\n        fileName.endsWith(\n          '/node_modules/.embroider/rewritten-app/assets/tests.js',\n        )\n      ) {\n        return false;\n      }\n\n      // Ideally, we never get here -- indicates we're not filtering effectively in babel\n      // NOTE: if we get here, we're trying to operate on a file too late.\n      //       we need ScopedCSS to operate as close to original source as possible -- not output files.\n      return false;\n    }\n  }\n\n  let workspace = findWorkspacePath(fileName);\n  let cwd = process.cwd();\n  let ourWorkspace = findWorkspacePath(cwd);\n\n  if (workspace !== ourWorkspace) {\n    return false;\n  }\n\n  let local = fileName.replace(workspace, '');\n  let [, ...parts] = local.split('/').filter(Boolean);\n\n  if (UNSUPPORTED_DIRECTORIES.has(parts[0])) {\n    return false;\n  }\n\n  /**\n   * Mostly pods support.\n   * folks need to opt in to pods (routes), because every pods app can be configured differently\n   */\n  let roots = ['/components/', ...(additionalRoots || [])];\n\n  if (!roots.some((root) => fileName.includes(root))) {\n    return;\n  }\n\n  return true;\n}\n\nexport function packageScopedPathToModulePath(packageScopedPath) {\n  /**\n   * *By convention*, `src` is omitted from component paths.\n   * We can reflect the same behavior by replacing src/\n   * with an empty string.\n   *\n   * CSS isn't emitted as a co-located module, but\n   * to keep conventions consistent across languages,\n   * we can pretend it is.\n   *\n   * Any customization beyond removing `src` and `app` is potentially confusing.\n   * If we need further customizations, we'll want to match on `exports` in the\n   * corresponding package.json\n   */\n  let packageRelative = packageScopedPath.replace(/^\\/src\\//, '/');\n\n  let parsed = path.parse(packageRelative);\n\n  if (isPod(packageRelative)) {\n    /**\n     * For pods, we chop off the whole file, and use the dir name as the \"modulePath\"\n     */\n    return parsed.dir;\n  }\n\n  /**\n   * If an extension is passed, remove it.\n   * When using packagers, folks are used to not having to specify extensions for files.\n   * Since we don't even emit css files co-located to each module,\n   * this helps us not convey a lie that a file may exist in at runtime.\n   *\n   * For example `<module-name>/components/button`.\n   * It doesn't matter what the extension is, because you can only have one css file\n   * for the button module anyway.\n   */\n  let localPackagerStylePath = path.join(parsed.dir, parsed.name);\n\n  return localPackagerStylePath;\n}\n\n/**\n * returns the app-module path of the source file\n *\n * This assumes normal ember app conventions\n *\n * which is `<package.json#name>/path-to-file`\n */\nexport function appPath(sourcePath) {\n  let workspacePath = findWorkspacePath(sourcePath);\n  let name = workspacePackageName(sourcePath);\n\n  /**\n   *  Under embroider builds, the spec-compliant version of the app\n   * has all the files under a folder which represents the package name,\n   * rather than \"app\".\n   */\n  let packageRelative = sourcePath.replace(workspacePath, '');\n\n  /**\n   * But we also don't want 'app' -- which is present in the v1 addon pipeline\n   */\n  packageRelative = packageRelative.replace(`/app/`, `/`);\n\n  /**\n   * also also, we know that the re-written app structure in embroider@v3\n   * is extraneous, and we can collapse it\n   */\n  packageRelative = packageRelative.replace(\n    `/node_modules/.embroider/rewritten-app/`,\n    '/',\n  );\n\n  let localPackagerStylePath = packageScopedPathToModulePath(packageRelative);\n\n  return `${name}${localPackagerStylePath}`;\n}\n\nconst CACHE = new Set();\n\n/**\n * For a given source path, if we have seen a\n * source file within the workspace directory,\n * find that workspace directory and return it.\n */\nfunction hasSeen(sourcePath) {\n  for (let entry of CACHE) {\n    if (sourcePath.startsWith(entry)) {\n      return entry;\n    }\n  }\n\n  // we have not seen this source path yet\n  return;\n}\n\n/**\n * Populates the \"seen\" workspace cache,\n * so that we don't hit the file system too often.\n */\nexport function findWorkspacePath(sourcePath) {\n  let seen = hasSeen(sourcePath);\n\n  if (seen) {\n    return seen;\n  }\n\n  const packageJsonPath = findUp.sync('package.json', {\n    cwd: path.dirname(sourcePath),\n  });\n\n  const workspacePath = path.dirname(packageJsonPath);\n\n  CACHE.add(workspacePath);\n\n  return workspacePath;\n}\n\nconst MANIFEST_CACHE = new Map();\n\n/**\n * returns the package.json#name for a given sourcePath\n */\nfunction workspacePackageName(sourcePath) {\n  const workspace = findWorkspacePath(sourcePath);\n\n  let existing = MANIFEST_CACHE.get(workspace);\n\n  if (existing) {\n    return existing.name;\n  }\n\n  let buffer = fsSync.readFileSync(path.join(workspace, 'package.json'));\n  let content = buffer.toString();\n  let json = JSON.parse(content);\n\n  MANIFEST_CACHE.set(workspace, json);\n\n  return json.name;\n}\n", "import md5 from 'blueimp-md5';\n\n/**\n * The intent of this function is to generate the suffix/postfix for the\n * css classes, based on the module-scoped path name.\n *\n * for example,\n *    hash('my-app/components/foo')\n *  instead of\n *    hash('app/components/foo')\n *\n *  (unless your app name is 'app')\n *\n * @param {string} modulePath\n * @returns {string}\n */\nexport function hash(modulePath) {\n  return 'e' + md5(modulePath).substring(0, 8);\n}\n\n\nexport const hashFromModulePath = hash;\n", "import { hash } from './hash-from-module-path.js';\nimport { appPath } from './utils.js';\n\nexport { hash } from './hash-from-module-path.js';\n\nexport function hashFromAbsolutePath(absolutePath) {\n  /**\n   * The whole of `appPath` ultimately transforms the `absolutePath`\n   * into the exact string that folks will pass to `relativePath`\n   * at runtime.\n   */\n  const modulePath = appPath(absolutePath);\n  const postfix = hash(modulePath);\n\n  return postfix;\n}\n", "import postcss from 'postcss';\nimport parser from 'postcss-selector-parser';\n\nimport isInsideGlobal from './isInsideGlobal.js';\n\nfunction rewriteSelector(sel, postfix) {\n  const transform = (selectors) => {\n    selectors.walk((selector) => {\n      if (selector.type === 'class' && !isInsideGlobal(selector)) {\n        selector.value += '_' + postfix;\n      } else if (selector.type === 'tag' && !isInsideGlobal(selector)) {\n        selector.replaceWith(\n          parser.tag({ value: selector.value }),\n          parser.className({ value: postfix }),\n        );\n      }\n    });\n\n    // remove :global\n    selectors.walk((selector) => {\n      if (selector.type === 'pseudo' && selector.value === ':global') {\n        selector.replaceWith(...selector.nodes);\n      }\n    });\n  };\n  const transformed = parser(transform).processSync(sel);\n\n  return transformed;\n}\n\nfunction isInsideKeyframes(node) {\n  const parent = node.parent;\n\n  if (!parent) return false;\n  if (parent.type === 'atrule' && parent.name === 'keyframes') return true;\n\n  return isInsideKeyframes(parent);\n}\n\nexport default function rewriteCss(css, postfix, fileName, layerName) {\n  const layerNameWithDefault = layerName ?? 'components';\n  const ast = postcss.parse(css);\n\n  ast.walk((node) => {\n    if (node.type === 'rule' && !isInsideKeyframes(node)) {\n      node.selector = rewriteSelector(node.selector, postfix);\n    }\n  });\n\n  const rewrittenCss = ast.toString();\n\n  if (!layerNameWithDefault) {\n    return `/* ${fileName} */\\n${rewrittenCss}\\n`;\n  }\n\n  return (\n    `/* ${fileName} */\\n@layer ${layerNameWithDefault} {\\n\\n` +\n    rewrittenCss +\n    '\\n}\\n'\n  );\n}\n\n", "export default function isInsideGlobal(node, func) {\n  const parent = node.parent;\n\n  if (!parent) return false;\n  if (parent.type === 'pseudo' && parent.value === ':global') return true;\n\n  return isInsideGlobal(parent, func);\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,IAAAA,kBAA2B;AAC3B,IAAAC,oBAAiB;;;ACFjB,qBAAmB;AACnB,uBAAiB;AAEjB,qBAAmB;;;ACHnB,yBAAgB;AAgBT,SAAS,KAAK,YAAY;AAC/B,SAAO,UAAM,mBAAAC,SAAI,UAAU,EAAE,UAAU,GAAG,CAAC;AAC7C;AAGO,IAAM,qBAAqB;;;AChB3B,SAAS,qBAAqB,cAAc;AAMjD,QAAM,aAAa,QAAQ,YAAY;AACvC,QAAM,UAAU,KAAK,UAAU;AAE/B,SAAO;AACT;;;AFGO,SAAS,SAAS,UAAU;AACjC,MAAI,SAAS,WAAW,GAAG,GAAG;AAC5B,WAAO,qBAAqB,QAAQ;AAAA,EACtC;AAEA,SAAO,mBAAmB,QAAQ;AACpC;AA4CO,SAAS,cAAc,UAAU;AACtC,MAAI,SAAS,SAAS,cAAc,GAAG;AACrC,WAAO;AAAA,EACT;AAEA,SAAO,SAAS,SAAS,aAAa,KAAK,SAAS,SAAS,cAAc;AAC7E;AAaO,SAAS,MAAM,UAAU;AAC9B,MAAI,SAAS,SAAS,cAAc,GAAG;AACrC,WAAO;AAAA,EACT;AAEA,MAAI,cAAc,QAAQ,GAAG;AAC3B,WAAO;AAAA,EACT;AAEA,SAAO,SAAS,SAAS,YAAY;AACvC;AA0FO,SAAS,8BAA8B,mBAAmB;AAc/D,MAAI,kBAAkB,kBAAkB,QAAQ,YAAY,GAAG;AAE/D,MAAI,SAAS,iBAAAC,QAAK,MAAM,eAAe;AAEvC,MAAI,MAAM,eAAe,GAAG;AAI1B,WAAO,OAAO;AAAA,EAChB;AAYA,MAAI,yBAAyB,iBAAAA,QAAK,KAAK,OAAO,KAAK,OAAO,IAAI;AAE9D,SAAO;AACT;AASO,SAAS,QAAQ,YAAY;AAClC,MAAI,gBAAgB,kBAAkB,UAAU;AAChD,MAAI,OAAO,qBAAqB,UAAU;AAO1C,MAAI,kBAAkB,WAAW,QAAQ,eAAe,EAAE;AAK1D,oBAAkB,gBAAgB,QAAQ,SAAS,GAAG;AAMtD,oBAAkB,gBAAgB;AAAA,IAChC;AAAA,IACA;AAAA,EACF;AAEA,MAAI,yBAAyB,8BAA8B,eAAe;AAE1E,SAAO,GAAG,IAAI,GAAG,sBAAsB;AACzC;AAEA,IAAM,QAAQ,oBAAI,IAAI;AAOtB,SAAS,QAAQ,YAAY;AAC3B,WAAS,SAAS,OAAO;AACvB,QAAI,WAAW,WAAW,KAAK,GAAG;AAChC,aAAO;AAAA,IACT;AAAA,EACF;AAGA;AACF;AAMO,SAAS,kBAAkB,YAAY;AAC5C,MAAI,OAAO,QAAQ,UAAU;AAE7B,MAAI,MAAM;AACR,WAAO;AAAA,EACT;AAEA,QAAM,kBAAkB,eAAAC,QAAO,KAAK,gBAAgB;AAAA,IAClD,KAAK,iBAAAD,QAAK,QAAQ,UAAU;AAAA,EAC9B,CAAC;AAED,QAAM,gBAAgB,iBAAAA,QAAK,QAAQ,eAAe;AAElD,QAAM,IAAI,aAAa;AAEvB,SAAO;AACT;AAEA,IAAM,iBAAiB,oBAAI,IAAI;AAK/B,SAAS,qBAAqB,YAAY;AACxC,QAAM,YAAY,kBAAkB,UAAU;AAE9C,MAAI,WAAW,eAAe,IAAI,SAAS;AAE3C,MAAI,UAAU;AACZ,WAAO,SAAS;AAAA,EAClB;AAEA,MAAI,SAAS,eAAAE,QAAO,aAAa,iBAAAF,QAAK,KAAK,WAAW,cAAc,CAAC;AACrE,MAAI,UAAU,OAAO,SAAS;AAC9B,MAAI,OAAO,KAAK,MAAM,OAAO;AAE7B,iBAAe,IAAI,WAAW,IAAI;AAElC,SAAO,KAAK;AACd;;;AGrUA,qBAAoB;AACpB,qCAAmB;;;ACDJ,SAAR,eAAgC,MAAM,MAAM;AACjD,QAAM,SAAS,KAAK;AAEpB,MAAI,CAAC,OAAQ,QAAO;AACpB,MAAI,OAAO,SAAS,YAAY,OAAO,UAAU,UAAW,QAAO;AAEnE,SAAO,eAAe,QAAQ,IAAI;AACpC;;;ADFA,SAAS,gBAAgB,KAAK,SAAS;AACrC,QAAM,YAAY,CAAC,cAAc;AAC/B,cAAU,KAAK,CAAC,aAAa;AAC3B,UAAI,SAAS,SAAS,WAAW,CAAC,eAAe,QAAQ,GAAG;AAC1D,iBAAS,SAAS,MAAM;AAAA,MAC1B,WAAW,SAAS,SAAS,SAAS,CAAC,eAAe,QAAQ,GAAG;AAC/D,iBAAS;AAAA,UACP,+BAAAG,QAAO,IAAI,EAAE,OAAO,SAAS,MAAM,CAAC;AAAA,UACpC,+BAAAA,QAAO,UAAU,EAAE,OAAO,QAAQ,CAAC;AAAA,QACrC;AAAA,MACF;AAAA,IACF,CAAC;AAGD,cAAU,KAAK,CAAC,aAAa;AAC3B,UAAI,SAAS,SAAS,YAAY,SAAS,UAAU,WAAW;AAC9D,iBAAS,YAAY,GAAG,SAAS,KAAK;AAAA,MACxC;AAAA,IACF,CAAC;AAAA,EACH;AACA,QAAM,kBAAc,+BAAAA,SAAO,SAAS,EAAE,YAAY,GAAG;AAErD,SAAO;AACT;AAEA,SAAS,kBAAkB,MAAM;AAC/B,QAAM,SAAS,KAAK;AAEpB,MAAI,CAAC,OAAQ,QAAO;AACpB,MAAI,OAAO,SAAS,YAAY,OAAO,SAAS,YAAa,QAAO;AAEpE,SAAO,kBAAkB,MAAM;AACjC;AAEe,SAAR,WAA4B,KAAK,SAAS,UAAU,WAAW;AACpE,QAAM,uBAAuB,aAAa;AAC1C,QAAM,MAAM,eAAAC,QAAQ,MAAM,GAAG;AAE7B,MAAI,KAAK,CAAC,SAAS;AACjB,QAAI,KAAK,SAAS,UAAU,CAAC,kBAAkB,IAAI,GAAG;AACpD,WAAK,WAAW,gBAAgB,KAAK,UAAU,OAAO;AAAA,IACxD;AAAA,EACF,CAAC;AAED,QAAM,eAAe,IAAI,SAAS;AAElC,MAAI,CAAC,sBAAsB;AACzB,WAAO,MAAM,QAAQ;AAAA,EAAQ,YAAY;AAAA;AAAA,EAC3C;AAEA,SACE,MAAM,QAAQ;AAAA,SAAe,oBAAoB;AAAA;AAAA,IACjD,eACA;AAEJ;;;AJrDA,eAAO,uBAAwB,MAAM;AACnC,QAAM,UAAU,KAAK,WAAW;AAChC,QAAM,UAAU,KAAK;AAErB,MAAI,CAAC,QAAQ,WAAW,KAAK,WAAW,GAAG;AACzC,WAAO;AAAA,EACT;AAEA,QAAM,cAAc,kBAAAC,QAAK,SAAS,OAAO;AAEzC,QAAM,UAAU,QAAQ,QAAQ,QAAQ,MAAM;AAC9C,QAAM,UAAU,QAAQ,QAAQ,QAAQ,KAAK;AAC7C,QAAM,gBAAY,4BAAW,OAAO;AACpC,QAAM,gBAAY,4BAAW,OAAO;AAEpC,MAAI,aAAa,WAAW;AAC1B,UAAM,UAAU,SAAS,OAAO;AAChC,UAAM,eAAe;AAAA,MACnB;AAAA,MACA;AAAA,MACA;AAAA,MACA,QAAQ;AAAA,IACV;AAEA,WAAO;AAAA,EACT;AAEA,SAAO;AACT;",
  "names": ["import_node_fs", "import_node_path", "md5", "path", "findUp", "fsSync", "parser", "postcss", "path"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/build/app-css-loader.js", "../../src/lib/path/utils.js", "../../src/lib/path/hash-from-module-path.js", "../../src/lib/path/hash-from-absolute-path.js", "../../src/lib/rewriteCss.js", "../../src/lib/isInsideGlobal.js"],
  "sourcesContent": ["// import { createUnplugin }  from 'unplugin';\nimport { existsSync } from 'node:fs';\nimport path from 'node:path';\n\nimport { hashFrom, isRelevantFile } from '../lib/path/utils.js';\nimport rewriteCss from '../lib/rewriteCss.js';\n\nexport default async function (code) {\n  const options = this.getOptions();\n  const cssPath = this.resourcePath;\n\n  if (!isRelevantFile(cssPath, { ...options, cwd: this.rootContext })) {\n    return code;\n  }\n\n  if (!cssPath.startsWith(this.rootContext)) {\n    return code;\n  }\n\n  const cssFileName = path.basename(cssPath);\n\n  const hbsPath = cssPath.replace('.css', '.hbs');\n  const gjsPath = cssPath.replace('.css', '.js');\n  const hbsExists = existsSync(hbsPath);\n  const gjsExists = existsSync(gjsPath);\n\n  if (hbsExists || gjsExists) {\n    const postfix = hashFrom(cssPath);\n    const rewrittenCss = rewriteCss(\n      code,\n      postfix,\n      cssFileName,\n      options.layerName,\n    );\n\n    return rewrittenCss;\n  }\n\n  return code;\n}\n", "import assert from 'node:assert';\nimport fsSync from 'node:fs';\nimport path from 'node:path';\n\nimport findUp from 'find-up';\n\nimport { hashFromAbsolutePath } from './hash-from-absolute-path.js';\nimport { hashFromModulePath } from './hash-from-module-path.js';\n\nexport { hashFromAbsolutePath } from './hash-from-absolute-path.js';\nexport { hashFromModulePath } from './hash-from-module-path.js';\n\nconst EMBROIDER_DIR = 'node_modules/.embroider';\nconst EMBROIDER_3_REWRITTEN_APP_PATH = `${EMBROIDER_DIR}/rewritten-app`;\nconst EMBROIDER_3_REWRITTEN_APP_ASSETS = `${EMBROIDER_3_REWRITTEN_APP_PATH}/assets`;\nconst EMBROIDER_3_REWRITTEN_PACKAGES = `${EMBROIDER_DIR}/rewritten-packages`;\nconst IRRELEVANT_PATHS = ['node_modules/.pnpm'];\nconst UNSUPPORTED_DIRECTORIES = new Set(['tests']);\n\n/**\n * Regardless of what the filePath format is,\n * this will try to return the correct postfix.\n *\n * @param {string} filePath\n * @returns\n */\nexport function hashFrom(filePath) {\n  if (filePath.startsWith('/')) {\n    return hashFromAbsolutePath(filePath);\n  }\n\n  return hashFromModulePath(filePath);\n}\n\n/**\n * Based on ember's component location conventions,\n * this function will provide a path for where we\n * expect the CSS to live.\n *\n * For co-located structure:\n *   - components/my-component.hbs\n *   - components/my-component.css\n *\n * For nested co-located structure\n *   - components/my-component/foo.hbs\n *   - components/my-component/foo.css\n *\n * For Pods routes structure\n *   - routes/my-route/template.{hbs,js}\n *   - routes/my-route/styles.css\n *\n * Deliberately not supported:\n *   - components w/ pods -- this is deprecated in 5.10\n *\n * @param {string} fileName - the hbs, js, gjs, gts or whatever co-located path.\n * @returns {string} - expected css path\n */\nexport function cssPathFor(fileName) {\n  let withoutExt = withoutExtension(fileName);\n  let cssPath = withoutExt + '.css';\n\n  if (isPod(fileName)) {\n    cssPath = fileName\n      .replace(/template\\.js$/, 'styles.css')\n      .replace(/template\\.hbs/, 'styles.css');\n  }\n\n  return cssPath;\n}\n\n/**\n * Note that components in the \"pods\" convention will\n * never be supported.\n *\n * @param {string} filePath\n */\nexport function isPodTemplate(filePath) {\n  if (filePath.includes('/components/')) {\n    return false;\n  }\n\n  return filePath.endsWith('template.js') || filePath.endsWith('template.hbs');\n}\n\n/**\n * Note that components in the \"pods\" convention will\n * never be supported.\n *\n * Checks if a file ends with\n * - template.js\n * - template.hbs\n * - styles.css\n *\n * @param {string} filePath\n */\nexport function isPod(filePath) {\n  if (filePath.includes('/components/')) {\n    return false;\n  }\n\n  if (isPodTemplate(filePath)) {\n    return true;\n  }\n\n  return filePath.endsWith('styles.css');\n}\n\n/**\n *\n * @param {string} filePath\n * @returns the same path, but without the extension\n */\nexport function withoutExtension(filePath) {\n  let parsed = path.parse(filePath);\n\n  return path.join(parsed.dir, parsed.name);\n}\n\n/**\n * Examples for fileName\n * - absolute on-disk path\n * - in webpack\n *   - URL-absolute path, starting with /\n *\n * @param {string} fileName\n * @param {{ additionalRoots?: string[]; cwd: string }} options\n * @returns\n */\nexport function isRelevantFile(fileName, { additionalRoots, cwd }) {\n  if (fileName.startsWith('/@embroider')) return false;\n  if (IRRELEVANT_PATHS.some((i) => fileName.includes(i))) return false;\n\n  if (fileName.includes('/node_modules/')) {\n    // if a file is not the embroider cache directory\n    // and is in node_modules, skip it.\n    if (!fileName.includes(EMBROIDER_DIR)) {\n      return false;\n    }\n\n    // rewritten packages should have already been processed at their own\n    // publish time\n    if (fileName.includes(EMBROIDER_3_REWRITTEN_PACKAGES)) {\n      return false;\n    }\n\n    // These are already the bundled files.\n    if (fileName.includes(EMBROIDER_3_REWRITTEN_APP_ASSETS)) {\n      // not supported, never will be\n      if (fileName.endsWith(`${EMBROIDER_3_REWRITTEN_APP_ASSETS}/tests.js`)) {\n        return false;\n      }\n\n      // Ideally, we never get here -- indicates we're not filtering effectively in babel\n      // NOTE: if we get here, we're trying to operate on a file too late.\n      //       we need ScopedCSS to operate as close to original source as possible -- not output files.\n      return false;\n    }\n  }\n\n  let workspace = findWorkspacePath(fileName);\n\n  assert(cwd, `cwd was not passed to isRelevantFile`);\n\n  let ourWorkspace = findWorkspacePath(cwd);\n\n  if (workspace !== ourWorkspace) {\n    return false;\n  }\n\n  let local = fileName.replace(workspace, '');\n  let [, ...parts] = local.split('/').filter(Boolean);\n\n  if (UNSUPPORTED_DIRECTORIES.has(parts[0])) {\n    return false;\n  }\n\n  /**\n   * Mostly pods support.\n   * folks need to opt in to pods (routes), because every pods app can be configured differently\n   */\n  let roots = ['/components/', '/templates/', ...(additionalRoots || [])];\n\n  if (!roots.some((root) => fileName.includes(root))) {\n    return;\n  }\n\n  return true;\n}\n\nexport function packageScopedPathToModulePath(packageScopedPath) {\n  /**\n   * *By convention*, `src` is omitted from component paths.\n   * We can reflect the same behavior by replacing src/\n   * with an empty string.\n   *\n   * CSS isn't emitted as a co-located module, but\n   * to keep conventions consistent across languages,\n   * we can pretend it is.\n   *\n   * Any customization beyond removing `src` and `app` is potentially confusing.\n   * If we need further customizations, we'll want to match on `exports` in the\n   * corresponding package.json\n   */\n  let packageRelative = packageScopedPath.replace(/^\\/src\\//, '/');\n\n  let parsed = path.parse(packageRelative);\n\n  if (isPod(packageRelative)) {\n    /**\n     * For pods, we chop off the whole file, and use the dir name as the \"modulePath\"\n     */\n    return parsed.dir;\n  }\n\n  /**\n   * If an extension is passed, remove it.\n   * When using packagers, folks are used to not having to specify extensions for files.\n   * Since we don't even emit css files co-located to each module,\n   * this helps us not convey a lie that a file may exist in at runtime.\n   *\n   * For example `<module-name>/components/button`.\n   * It doesn't matter what the extension is, because you can only have one css file\n   * for the button module anyway.\n   */\n  let localPackagerStylePath = path.join(parsed.dir, parsed.name);\n\n  return localPackagerStylePath;\n}\n\n/**\n * returns the app-module path of the source file\n *\n * This assumes normal ember app conventions\n *\n * which is `<package.json#name>/path-to-file`\n */\nexport function appPath(sourcePath) {\n  let workspacePath = findWorkspacePath(sourcePath);\n  let name = workspacePackageName(sourcePath);\n\n  /**\n   *  Under embroider builds, the spec-compliant version of the app\n   * has all the files under a folder which represents the package name,\n   * rather than \"app\".\n   */\n  let packageRelative = sourcePath.replace(workspacePath, '');\n\n  /**\n   * But we also don't want 'app' -- which is present in the v1 addon pipeline\n   */\n  packageRelative = packageRelative.replace(`/app/`, `/`);\n\n  /**\n   * also also, we know that the re-written app structure in embroider@v3\n   * is extraneous, and we can collapse it\n   */\n  packageRelative = packageRelative.replace(\n    `${EMBROIDER_3_REWRITTEN_APP_PATH}/`,\n    '/',\n  );\n\n  let localPackagerStylePath = packageScopedPathToModulePath(packageRelative);\n\n  return `${name}${localPackagerStylePath}`;\n}\n\nexport function findWorkspacePath(sourcePath) {\n  if (sourcePath.includes(EMBROIDER_3_REWRITTEN_APP_PATH)) {\n    sourcePath = sourcePath.split(EMBROIDER_3_REWRITTEN_APP_PATH)[0];\n  }\n\n  if (sourcePath.endsWith('/')) {\n    sourcePath = sourcePath.replace(/\\/$/, '');\n  }\n\n  let candidatePath = path.join(sourcePath, 'package.json');\n\n  const isWorkspace = fsSync.existsSync(candidatePath);\n\n  if (isWorkspace) {\n    return sourcePath;\n  }\n\n  const packageJsonPath = findUp.sync('package.json', {\n    cwd: path.dirname(sourcePath),\n  });\n\n  const workspacePath = path.dirname(packageJsonPath);\n\n  return workspacePath;\n}\n\nconst MANIFEST_CACHE = new Map();\n\n/**\n * returns the package.json#name for a given sourcePath\n */\nfunction workspacePackageName(sourcePath) {\n  const workspace = findWorkspacePath(sourcePath);\n\n  let existing = MANIFEST_CACHE.get(workspace);\n\n  if (existing) {\n    return existing.name;\n  }\n\n  let buffer = fsSync.readFileSync(path.join(workspace, 'package.json'));\n  let content = buffer.toString();\n  let json = JSON.parse(content);\n\n  MANIFEST_CACHE.set(workspace, json);\n\n  return json.name;\n}\n", "import md5 from 'blueimp-md5';\n\n/**\n * The intent of this function is to generate the suffix/postfix for the\n * css classes, based on the module-scoped path name.\n *\n * for example,\n *    hash('my-app/components/foo')\n *  instead of\n *    hash('app/components/foo')\n *\n *  (unless your app name is 'app')\n *\n * @param {string} modulePath\n * @returns {string}\n */\nexport function hash(modulePath) {\n  return 'e' + md5(modulePath).substring(0, 8);\n}\n\n\nexport const hashFromModulePath = hash;\n", "import { hash } from './hash-from-module-path.js';\nimport { appPath } from './utils.js';\n\nexport { hash } from './hash-from-module-path.js';\n\nexport function hashFromAbsolutePath(absolutePath) {\n  /**\n   * The whole of `appPath` ultimately transforms the `absolutePath`\n   * into the exact string that folks will pass to `relativePath`\n   * at runtime.\n   */\n  const modulePath = appPath(absolutePath);\n  const postfix = hash(modulePath);\n\n  return postfix;\n}\n", "import postcss from 'postcss';\nimport parser from 'postcss-selector-parser';\n\nimport isInsideGlobal from './isInsideGlobal.js';\n\nfunction rewriteSelector(sel, postfix) {\n  const transform = (selectors) => {\n    selectors.walk((selector) => {\n      if (selector.type === 'class' && !isInsideGlobal(selector)) {\n        selector.value += '_' + postfix;\n      } else if (selector.type === 'tag' && !isInsideGlobal(selector)) {\n        selector.replaceWith(\n          parser.tag({ value: selector.value }),\n          parser.className({ value: postfix }),\n        );\n      }\n    });\n\n    // remove :global\n    selectors.walk((selector) => {\n      if (selector.type === 'pseudo' && selector.value === ':global') {\n        selector.replaceWith(...selector.nodes);\n      }\n    });\n  };\n  const transformed = parser(transform).processSync(sel);\n\n  return transformed;\n}\n\nfunction isInsideKeyframes(node) {\n  const parent = node.parent;\n\n  if (!parent) return false;\n  if (parent.type === 'atrule' && parent.name === 'keyframes') return true;\n\n  return isInsideKeyframes(parent);\n}\n\nexport default function rewriteCss(css, postfix, fileName, layerName) {\n  const layerNameWithDefault = layerName ?? 'components';\n  const ast = postcss.parse(css);\n\n  ast.walk((node) => {\n    if (node.type === 'rule' && !isInsideKeyframes(node)) {\n      node.selector = rewriteSelector(node.selector, postfix);\n    }\n  });\n\n  const rewrittenCss = ast.toString();\n\n  if (!layerNameWithDefault) {\n    return `/* ${fileName} */\\n${rewrittenCss}\\n`;\n  }\n\n  return (\n    `/* ${fileName} */\\n@layer ${layerNameWithDefault} {\\n\\n` +\n    rewrittenCss +\n    '\\n}\\n'\n  );\n}\n\n", "export default function isInsideGlobal(node, func) {\n  const parent = node.parent;\n\n  if (!parent) return false;\n  if (parent.type === 'pseudo' && parent.value === ':global') return true;\n\n  return isInsideGlobal(parent, func);\n}\n"],
  "mappings": "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",
  "names": ["import_node_fs", "import_node_path", "md5", "assert", "path", "fsSync", "findUp", "parser", "postcss", "path"]
}
