ember-scoped-css 0.18.0 → 0.19.0

package/README.md

@@ -19,6 +19,13 @@ This build tool emits CSS in a `@layer`.
 - non-embroider apps 
 - embroider apps
 
+| You Have | ember-scoped-css | ember-scoped-css-compat |
+| -------- | ----------- | ---------------------- |
+| ember-template-imports@v4 or babel-plugin-ember-template-compilation@2.2.5+ | 0.19.0 | 10.0.0 |
+| ember-template-imports@v3 or babel-plugin-ember-template-compilation@2.2.1 or rollup-plugin-glimmer-template-tag | <= 0.18.0 | <= 9.0.0 |
+| classic components | <= 0.18.0 | <= 8.0.0 |
+| ember < 4 | <= 0.18.0 | <= 8.0.0 |
+
 
 ## Installation for a non-embroider ember app
 

package/declarations/lib/path/hash-from-absolute-path.d.ts

@@ -0,0 +1,3 @@
+export function hashFromAbsolutePath(absolutePath: any): string;
+export { hash } from "./hash-from-module-path.js";
+//# sourceMappingURL=hash-from-absolute-path.d.ts.map

package/declarations/lib/path/hash-from-absolute-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash-from-absolute-path.d.ts","sourceRoot":"","sources":["../../../src/lib/path/hash-from-absolute-path.js"],"names":[],"mappings":"AAKA,gEAUC"}

package/declarations/lib/path/hash-from-absolute-path.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=hash-from-absolute-path.test.d.ts.map

package/declarations/lib/path/hash-from-absolute-path.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash-from-absolute-path.test.d.ts","sourceRoot":"","sources":["../../../src/lib/path/hash-from-absolute-path.test.ts"],"names":[],"mappings":""}

package/declarations/lib/path/hash-from-module-path.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The intent of this function is to generate the suffix/postfix for the
+ * css classes, based on the module-scoped path name.
+ *
+ * for example,
+ *    hash('my-app/components/foo')
+ *  instead of
+ *    hash('app/components/foo')
+ *
+ *  (unless your app name is 'app')
+ *
+ * @param {string} modulePath
+ * @returns {string}
+ */
+export function hash(modulePath: string): string;
+/**
+ * The intent of this function is to generate the suffix/postfix for the
+ * css classes, based on the module-scoped path name.
+ *
+ * for example,
+ *    hash('my-app/components/foo')
+ *  instead of
+ *    hash('app/components/foo')
+ *
+ *  (unless your app name is 'app')
+ *
+ * @param {string} modulePath
+ * @returns {string}
+ */
+export function hashFromModulePath(modulePath: string): string;
+//# sourceMappingURL=hash-from-module-path.d.ts.map

package/declarations/lib/path/hash-from-module-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash-from-module-path.d.ts","sourceRoot":"","sources":["../../../src/lib/path/hash-from-module-path.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,iCAHW,MAAM,GACJ,MAAM,CAIlB;AAhBD;;;;;;;;;;;;;GAaG;AACH,+CAHW,MAAM,GACJ,MAAM,CAIlB"}

package/declarations/lib/path/template-transform-paths.d.ts

@@ -0,0 +1,11 @@
+/**
+ * template plugins do not hand us the correct file path.
+ * additionally, we may not be able to rely on this data in the future,
+ * so this functions acts as a means of normalizing _whatever_ we're given
+ * in the future.
+ *
+ * @param {string} filename
+ * @returns {string} the absolute path to the file
+ */
+export function fixFilename(filename: string): string;
+//# sourceMappingURL=template-transform-paths.d.ts.map

package/declarations/lib/path/template-transform-paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"template-transform-paths.d.ts","sourceRoot":"","sources":["../../../src/lib/path/template-transform-paths.js"],"names":[],"mappings":"AAMA;;;;;;;;GAQG;AACH,sCAHW,MAAM,GACJ,MAAM,CAqElB"}

package/declarations/lib/path/template-transform-paths.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=template-transform-paths.test.d.ts.map

package/declarations/lib/path/template-transform-paths.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"template-transform-paths.test.d.ts","sourceRoot":"","sources":["../../../src/lib/path/template-transform-paths.test.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=utils.appPath.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.appPath.test.d.ts","sourceRoot":"","sources":["../../../src/lib/path/utils.appPath.test.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,85 @@
+/**
+ * Regardless of what the filePath format is,
+ * this will try to return the correct postfix.
+ *
+ * @param {string} filePath
+ * @returns
+ */
+export function hashFrom(filePath: string): string;
+/**
+ * Based on ember's component location conventions,
+ * this function will provide a path for where we
+ * expect the CSS to live.
+ *
+ * For co-located structure:
+ *   - components/my-component.hbs
+ *   - components/my-component.css
+ *
+ * For nested co-located structure
+ *   - components/my-component/foo.hbs
+ *   - components/my-component/foo.css
+ *
+ * For Pods routes structure
+ *   - routes/my-route/template.{hbs,js}
+ *   - routes/my-route/styles.css
+ *
+ * Deliberately not supported:
+ *   - components w/ pods -- this is deprecated in 5.10
+ *
+ * @param {string} fileName - the hbs, js, gjs, gts or whatever co-located path.
+ * @returns {string} - expected css path
+ */
+export function cssPathFor(fileName: string): string;
+/**
+ * Note that components in the "pods" convention will
+ * never be supported.
+ *
+ * @param {string} filePath
+ */
+export function isPodTemplate(filePath: string): boolean;
+/**
+ * Note that components in the "pods" convention will
+ * never be supported.
+ *
+ * Checks if a file ends with
+ * - template.js
+ * - template.hbs
+ * - styles.css
+ *
+ * @param {string} filePath
+ */
+export function isPod(filePath: string): boolean;
+/**
+ *
+ * @param {string} filePath
+ * @returns the same path, but without the extension
+ */
+export function withoutExtension(filePath: string): string;
+/**
+ * Examples for fileName
+ * - absolute on-disk path
+ * - in webpack
+ *   - URL-absolute path, starting with /
+ *
+ * @param {string} fileName
+ * @param {string[]} [additionalRoots]
+ * @returns
+ */
+export function isRelevantFile(fileName: string, additionalRoots?: string[] | undefined): boolean | undefined;
+export function packageScopedPathToModulePath(packageScopedPath: any): string;
+/**
+ * returns the app-module path of the source file
+ *
+ * This assumes normal ember app conventions
+ *
+ * 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";
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +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,+DAmEhB;AAED,8EAsCC;AAED;;;;;;GAMG;AACH,iDA4BC;AAoBD;;;GAGG;AACH,wDAgBC"}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=utils.hashFrom.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.hashFrom.test.d.ts","sourceRoot":"","sources":["../../../src/lib/path/utils.hashFrom.test.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=utils.isRelevantFile.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.isRelevantFile.test.d.ts","sourceRoot":"","sources":["../../../src/lib/path/utils.isRelevantFile.test.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,7 @@
+export declare const paths: {
+    rewritten: string;
+    embroiderApp: string;
+    classicApp: string;
+    v2Addon: string;
+};
+//# sourceMappingURL=utils.paths.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.paths.test.d.ts","sourceRoot":"","sources":["../../../src/lib/path/utils.paths.test.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,KAAK;;;;;CAKjB,CAAC"}

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

@@ -0,0 +1,220 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/build/app-css-loader.js
+var app_css_loader_exports = {};
+__export(app_css_loader_exports, {
+  default: () => app_css_loader_default
+});
+module.exports = __toCommonJS(app_css_loader_exports);
+var import_node_fs2 = require("node:fs");
+var import_node_path2 = __toESM(require("node:path"), 1);
+
+// src/lib/path/utils.js
+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);
+
+// src/lib/path/hash-from-module-path.js
+var import_blueimp_md5 = __toESM(require("blueimp-md5"), 1);
+function hash(modulePath) {
+  return "e" + (0, import_blueimp_md5.default)(modulePath).substring(0, 8);
+}
+var hashFromModulePath = hash;
+
+// src/lib/path/hash-from-absolute-path.js
+function hashFromAbsolutePath(absolutePath) {
+  const modulePath = appPath(absolutePath);
+  const postfix = hash(modulePath);
+  return postfix;
+}
+
+// src/lib/path/utils.js
+function hashFrom(filePath) {
+  if (filePath.startsWith("/")) {
+    return hashFromAbsolutePath(filePath);
+  }
+  return hashFromModulePath(filePath);
+}
+function isPodTemplate(filePath) {
+  if (filePath.includes("/components/")) {
+    return false;
+  }
+  return filePath.endsWith("template.js") || filePath.endsWith("template.hbs");
+}
+function isPod(filePath) {
+  if (filePath.includes("/components/")) {
+    return false;
+  }
+  if (isPodTemplate(filePath)) {
+    return true;
+  }
+  return filePath.endsWith("styles.css");
+}
+function packageScopedPathToModulePath(packageScopedPath) {
+  let packageRelative = packageScopedPath.replace(/^\/src\//, "/");
+  let parsed = import_node_path.default.parse(packageRelative);
+  if (isPod(packageRelative)) {
+    return parsed.dir;
+  }
+  let localPackagerStylePath = import_node_path.default.join(parsed.dir, parsed.name);
+  return localPackagerStylePath;
+}
+function appPath(sourcePath) {
+  let workspacePath = findWorkspacePath(sourcePath);
+  let name = workspacePackageName(sourcePath);
+  let packageRelative = sourcePath.replace(workspacePath, "");
+  packageRelative = packageRelative.replace(`/app/`, `/`);
+  packageRelative = packageRelative.replace(
+    `/node_modules/.embroider/rewritten-app/`,
+    "/"
+  );
+  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;
+  }
+  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();
+function workspacePackageName(sourcePath) {
+  const workspace = findWorkspacePath(sourcePath);
+  let existing = MANIFEST_CACHE.get(workspace);
+  if (existing) {
+    return existing.name;
+  }
+  let buffer = import_node_fs.default.readFileSync(import_node_path.default.join(workspace, "package.json"));
+  let content = buffer.toString();
+  let json = JSON.parse(content);
+  MANIFEST_CACHE.set(workspace, json);
+  return json.name;
+}
+
+// src/lib/rewriteCss.js
+var import_postcss = __toESM(require("postcss"), 1);
+var import_postcss_selector_parser = __toESM(require("postcss-selector-parser"), 1);
+
+// src/lib/isInsideGlobal.js
+function isInsideGlobal(node, func) {
+  const parent = node.parent;
+  if (!parent) return false;
+  if (parent.type === "pseudo" && parent.value === ":global") return true;
+  return isInsideGlobal(parent, func);
+}
+
+// src/lib/rewriteCss.js
+function rewriteSelector(sel, postfix) {
+  const transform = (selectors) => {
+    selectors.walk((selector) => {
+      if (selector.type === "class" && !isInsideGlobal(selector)) {
+        selector.value += "_" + postfix;
+      } else if (selector.type === "tag" && !isInsideGlobal(selector)) {
+        selector.replaceWith(
+          import_postcss_selector_parser.default.tag({ value: selector.value }),
+          import_postcss_selector_parser.default.className({ value: postfix })
+        );
+      }
+    });
+    selectors.walk((selector) => {
+      if (selector.type === "pseudo" && selector.value === ":global") {
+        selector.replaceWith(...selector.nodes);
+      }
+    });
+  };
+  const transformed = (0, import_postcss_selector_parser.default)(transform).processSync(sel);
+  return transformed;
+}
+function isInsideKeyframes(node) {
+  const parent = node.parent;
+  if (!parent) return false;
+  if (parent.type === "atrule" && parent.name === "keyframes") return true;
+  return isInsideKeyframes(parent);
+}
+function rewriteCss(css, postfix, fileName, layerName) {
+  const layerNameWithDefault = layerName ?? "components";
+  const ast = import_postcss.default.parse(css);
+  ast.walk((node) => {
+    if (node.type === "rule" && !isInsideKeyframes(node)) {
+      node.selector = rewriteSelector(node.selector, postfix);
+    }
+  });
+  const rewrittenCss = ast.toString();
+  if (!layerNameWithDefault) {
+    return `/* ${fileName} */
+${rewrittenCss}
+`;
+  }
+  return `/* ${fileName} */
+@layer ${layerNameWithDefault} {
+
+` + rewrittenCss + "\n}\n";
+}
+
+// src/build/app-css-loader.js
+async function app_css_loader_default(code) {
+  const options = this.getOptions();
+  const cssPath = this.resourcePath;
+  if (!cssPath.startsWith(this.rootContext)) {
+    return code;
+  }
+  const cssFileName = import_node_path2.default.basename(cssPath);
+  const hbsPath = cssPath.replace(".css", ".hbs");
+  const gjsPath = cssPath.replace(".css", ".js");
+  const hbsExists = (0, import_node_fs2.existsSync)(hbsPath);
+  const gjsExists = (0, import_node_fs2.existsSync)(gjsPath);
+  if (hbsExists || gjsExists) {
+    const postfix = hashFrom(cssPath);
+    const rewrittenCss = rewriteCss(
+      code,
+      postfix,
+      cssFileName,
+      options.layerName
+    );
+    return rewrittenCss;
+  }
+  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      console.warn(\n        `[ScopedCSS]: transformation is attempting too late. Cannot operate on output file: ${fileName}`,\n      );\n\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": "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",
  "names": ["import_node_fs", "import_node_path", "md5", "path", "findUp", "fsSync", "parser", "postcss", "path"]
}


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

@@ -0,0 +1,41 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/build/app-dependency-loader.js
+var app_dependency_loader_exports = {};
+__export(app_dependency_loader_exports, {
+  default: () => app_dependency_loader_default
+});
+module.exports = __toCommonJS(app_dependency_loader_exports);
+var import_node_fs = require("node:fs");
+function app_dependency_loader_default(source) {
+  if (this.resourcePath.endsWith(".js")) {
+    const hbsExists = (0, import_node_fs.existsSync)(this.resourcePath.replace(/\.js/, ".hbs"));
+    if (hbsExists) {
+      return source;
+    }
+  }
+  const cssPath = this.resourcePath.replace(/(\.js)|(\.hbs)/, ".css");
+  const cssExists = (0, import_node_fs.existsSync)(cssPath);
+  if (cssExists) {
+    this.addDependency(cssPath);
+  }
+  return source;
+}
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vc3JjL2J1aWxkL2FwcC1kZXBlbmRlbmN5LWxvYWRlci5qcyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiaW1wb3J0IHsgZXhpc3RzU3luYyB9IGZyb20gJ25vZGU6ZnMnO1xuXG5leHBvcnQgZGVmYXVsdCBmdW5jdGlvbiAoc291cmNlKSB7XG4gIGlmICh0aGlzLnJlc291cmNlUGF0aC5lbmRzV2l0aCgnLmpzJykpIHtcbiAgICBjb25zdCBoYnNFeGlzdHMgPSBleGlzdHNTeW5jKHRoaXMucmVzb3VyY2VQYXRoLnJlcGxhY2UoL1xcLmpzLywgJy5oYnMnKSk7XG5cbiAgICBpZiAoaGJzRXhpc3RzKSB7XG4gICAgICByZXR1cm4gc291cmNlO1xuICAgIH1cbiAgfVxuXG4gIGNvbnN0IGNzc1BhdGggPSB0aGlzLnJlc291cmNlUGF0aC5yZXBsYWNlKC8oXFwuanMpfChcXC5oYnMpLywgJy5jc3MnKTtcbiAgY29uc3QgY3NzRXhpc3RzID0gZXhpc3RzU3luYyhjc3NQYXRoKTtcblxuICBpZiAoY3NzRXhpc3RzKSB7XG4gICAgdGhpcy5hZGREZXBlbmRlbmN5KGNzc1BhdGgpO1xuICB9XG5cbiAgcmV0dXJuIHNvdXJjZTtcbn1cbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBLHFCQUEyQjtBQUVaLFNBQVIsOEJBQWtCLFFBQVE7QUFDL0IsTUFBSSxLQUFLLGFBQWEsU0FBUyxLQUFLLEdBQUc7QUFDckMsVUFBTSxnQkFBWSwyQkFBVyxLQUFLLGFBQWEsUUFBUSxRQUFRLE1BQU0sQ0FBQztBQUV0RSxRQUFJLFdBQVc7QUFDYixhQUFPO0FBQUEsSUFDVDtBQUFBLEVBQ0Y7QUFFQSxRQUFNLFVBQVUsS0FBSyxhQUFhLFFBQVEsa0JBQWtCLE1BQU07QUFDbEUsUUFBTSxnQkFBWSwyQkFBVyxPQUFPO0FBRXBDLE1BQUksV0FBVztBQUNiLFNBQUssY0FBYyxPQUFPO0FBQUEsRUFDNUI7QUFFQSxTQUFPO0FBQ1Q7IiwKICAibmFtZXMiOiBbXQp9Cg==