ember-scoped-css 0.24.2 → 1.0.0

package/README.md

@@ -1,8 +1,42 @@
 # ember-scoped-css
 
-`ember-scoped-css` is a modern addon that allows you to isolate your CSS in a modular way with co-located scoped CSS. This is a build-time-only addon and therefore is fully supported if your app is built with Embroider.
+Scope your component styles and never worry about a collision ever again.
 
-With `ember-scoped-css` you can write your component styles in a co-located `.css` file next to your `.hbs` or `.gjs/.gts` files. Every selector you write in your styles is automatically scoped to the component. So you can develop your component with styles isolated from the rest of the application and you don't have to worry about CSS selectors collisions or issues with the CSS cascade.
+```gjs
+const greeting = "hello world";
+
+<template>
+  <div>{{greeting}}</div>
+
+  <style scoped>
+    div {
+      color: blue;
+    }
+  </style>
+</template>
+```
+becomes the equivelent of;
+```gjs
+const greeting = "hello world";
+
+<template>
+  <div class="abcd1234">{{greeting}}</div>
+
+  <style scoped>
+    div.abcd1234 {
+      color: blue;
+    }
+  </style>
+</template>
+```
+
+This is a build-time-only addon, so there is no need to worry about runtime performance.
+
+You can also write your styles as a co-located `.css` file, right next to your `.gjs`/`.gts` files.
+Every selector you write in your styles is automatically scoped to the component. 
+So you can develop your component with styles isolated from the rest of the application and you don't have to worry about CSS selectors collisions or issues with the CSS cascade.
+
+_See [Usage](#usage) for details_.
 
 If you want to read more specifics on how this addon achieves isolation with CSS you can read more in the [detailed CSS isolation documentation](docs/css-isolation.md)
 
@@ -11,7 +45,7 @@ As selectors are scoped/renamed during the build process. So there is no perform
 The philosophy of `ember-scoped-css` is to stick as close to CSS and HTML as possible and not introduce new syntax or concepts unless it is absolutely necessary. 
 
 You may also find the docs on [CSS `@layer`](https://developer.mozilla.org/en-US/docs/Web/CSS/@layer) interesting.
-This build tool emits CSS in a `@layer`.
+This build tool can emit CSS in a `@layer`.
 
 ## Compatibility
 
@@ -20,12 +54,21 @@ 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 |
+| You Have | ember-scoped-css | ember-scoped-css-compat | docs |
+| -------- | ----------- | ---------------------- | --- |
+| vite | >= 1.0.0 | 🚫 | [main][docs-main]
+| gjs / gts library (no hbs) | >= 1.0.0 | 🚫 | [main][docs-main]
+| webpack | <= 0.24.3 | <= 10.0.0 | [0.24.3][docs-2] 
+| hbs | <= 0.24.3 | <= 10.0.0 | [0.24.3][docs-2]
+| ember-template-imports@v4 or babel-plugin-ember-template-compilation@2.2.5+ | 0.19.0 | 10.0.0 | [0.19][docs-3] - [0.24][docs-2]
+| 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 | [0.18][docs-4]
+| classic components | <= 0.18.0 | <= 8.0.0 | [0.18][docs-4]
+| ember < 4 | <= 0.18.0 | <= 8.0.0 | [0.18][docs-4]
+
+[docs-main]: https://github.com/auditboard/ember-scoped-css/
+[docs-2]: https://github.com/auditboard/ember-scoped-css/tree/v0.24.3-ember-scoped-css
+[docs-3]: https://github.com/auditboard/ember-scoped-css/tree/v0.19.1-ember-scoped-css
+[docs-4]: https://github.com/auditboard/ember-scoped-css/tree/ember-scoped-css%400.18.0
 
 ## Installation for a Vite app
 
@@ -56,6 +99,7 @@ import * as scopedCSS from "ember-scoped-css/build";
 module.exports = {
   plugins: [
     // ...
+    [scopedCSS.babelPlugin, {}],
     [
       'babel-plugin-ember-template-compilation',
       {
@@ -70,29 +114,16 @@ module.exports = {
 
 ```
 
-## Installation for a non-embroider ember app
+If you have a rollup config:
+```js
+import * as scopedCss from 'ember-scoped-css/build';
 
-```bash
-npm install --save-dev ember-scoped-css ember-scoped-css-compat
+// ...
+plugins: [
+    scopedCss.rollupPlugin(),
+]
 ```
 
-### Configuration
-
-In your `ember-cli-build.js`, you can configure the behavior of scoped-css transformations within the app via 
-```js 
-
-const app = new EmberApp(defaults, { 
-  /* ... */ 
-  'ember-scoped-css': {
-    layerName: 'app-styles', // default: 'components', set to false to disable the layer
-    additionalRoots: ['routes/'], // default: [], set this to use scoped-css in pods-using apps
-    passthrough: ['some-other-file.css'], // default: [] this is only used in a non-embroider app to pass files through the build pipeline
-    passthroughDestination: 'assets' // default: undefined this alters where the passthrough files are placed in the output tree
-  }
-});
-```
-
-Note that supporting `pods` is _opt in_, because all apps can have their pods root directory configured differently.
 
 ## Installation for an embroider app
 
@@ -100,91 +131,62 @@ Note that supporting `pods` is _opt in_, because all apps can have their pods ro
 npm install --save-dev ember-scoped-css ember-scoped-css-compat
 ```
 
-Setup webpack:
-```js 
-// ember-cli-build.js
-module.exports = async function (defaults) {  
-  const app = new EmberApp(defaults, { /* ... */ });
-
-  const { Webpack } = require('@embroider/webpack');
-
-  return require('@embroider/compat').compatBuild(app, Webpack, {
-    /* ... */
-    packagerOptions: {
-      webpackConfig: {
-        module: {
-          rules: [
-            // css loaders for your app CSS
-            {
-              test: /\.css$/,
-              use: [
-                {
-                  loader: require.resolve(
-                    'ember-scoped-css/build/app-css-loader'
-                  ),
-                  options: {
-                    layerName: 'the-layer-name', // optional
-                  }
-                },
-              ],
-            },
-          ],
-        },
-      },
-    },
-  });
-}
-```
-
-## Installation for a V2 Addon
-
-```
-npm install --save-dev ember-scoped-css
-```
-
-1. If you want to use `.gjs/gts` components, [`@embroider/addon-dev`](https://github.com/embroider-build/embroider/tree/main/packages/addon-dev) provides a plugin for you, `addon.gjs()`.
-
-<details><summary>An older approach</summary>
-
-There is a deprecated plugin (superseded by `@embroider/addon-dev`) that uses ember-template-imports -- to use this follow the instructions from [rollup-plugin-glimmer-template-tag](https://github.com/NullVoxPopuli/rollup-plugin-glimmer-template-tag) addon.
-
-This plugin is not recommended, and is archived.
-
-</details>
+### Configuration
 
-2. Add the following to your `rollup.config.mjs`:
+All forms of `scopedCss` take an options hash except for the rollup and vite plugins.
 
-```diff
-+ import { scopedCssUnplugin } from 'ember-scoped-css/build';
+Configuration in the two locations in the babel config should match, for example:
 
-// if you want to have some global styles in your addon then
-// put them in the styles folder and change the path to the styles folder
-// if there are no global styles then you can remove addon.keepAssets
-- addon.keepAssets(['**/*.css']),
-+ addon.keepAssets(['**/styles/*.css']),
 
-// add the following to the rollup config
-+ scopedCssUnplugin.rollup(),
+```js
+plugins: [
+  [scopedCSS.babelPlugin, { layerName: 'my-library' }],
+
+  [
+    'babel-plugin-ember-template-compilation',
+    {
+      targetFormat: 'hbs',
+      transforms: [scopedCSS.templatePlugin({ layerName: 'my-libarry' })],
+    },
+  ],
+],
 ```
 
-Note that if you're using [`rollup-plugin-ts`](https://github.com/wessberg/rollup-plugin-ts), `scopedCssUnpulugin.rollup()` must come before `typescript(/*...*/)` 
+## Usage
 
-### Configuration
+With `ember-scoped-css` you define styles in an inline `<style scoped>` block or `.css` files that are colocated with your components
 
-In the rollup config, you may pass options:
+```gjs
+// ...
 
-```js 
-scopedCssUnplugin.rollup({ 
-  layerName: 'utilities', // default: 'components', set to false to disable the layer
-});
+<template>
+  <div data-test-my-component class='hello-class header'>
+    <b>Hello</b>, world!
+  </div>
+
+  <style scoped>
+    .hello-class {
+      color: red;
+    }
+
+    /* the :global() pseudo-class is used to define a global class. 
+       It mean that header class wont be scoped to that component */
+    .hello-class:global(.header) {
+      font-size: 20px;
+    }
+
+    b {
+      color: blue;
+    }
+  </style>
+</template>
 ```
 
-## Usage
+Note that `<style>` (without `scoped`) will continue to work as it does today and be "global styles"
 
-With `ember-scoped-css` you define styles in `.css` files that are colocated with your components
+<details><summary>separate CSS file</summary>
 
 ```hbs
-{{! src/components/my-component.hbs }}
 <div data-test-my-component class='hello-class header'><b>Hello</b>, world!</div>
 ```
 
@@ -206,22 +208,14 @@ b {
 
 NOTE: that if you're using pods, css co-located with templates/routes/etc will need to be named `styles.css`
 
+</details>
+
 
 
 ### Passing classes as arguments to a component
 
-There is a `scoped-class` helper that you can use to pass a class name as an argument to a component. The helper takes a class name and returns a scoped class name. `scoped-class` helper is replaced at build time so there is no performance hit when running the app.
+There is a `scopedClass` helper that you can use to pass a class name as an argument to a component. The helper takes a class name and returns a scoped class name. `scopedClass` helper is replaced at build time so there is no performance hit when running the app.
 
-```hbs
-{{! src/components/my-component.hbs }}
-<OtherComponent @internalClass={{scoped-class 'hello-class'}} />
-<OtherComponent @internalClass={{(scoped-class 'hello-class')}} />
-<OtherComponent
-  @internalClass={{concat (scoped-class 'hello-class') ' other-class'}}
-/>
-```
-
-In gjs/gts/`<template>`, the above would look like:
 ```gjs
 import { scopedClass } from 'ember-scoped-css';
 
@@ -240,15 +234,15 @@ As classes are renamed during the build process you can't directly verify if cla
 
 The path to the CSS file is always relative to the V2 addon root no matter where the test is located.
 
-```js
+```gjs
 import { scopedClass } from 'ember-scoped-css/test-support';
 
 test('MyComponent has hello-class', async function (assert) {
   assert.expect(1);
 
-  await render(hbs`
+  await render(<template>
     <MyComponent />
-  `);
+  </template>);
 
   const rewrittenClass = scopedClass(
     'hello-class',
@@ -261,7 +255,7 @@ test('MyComponent has hello-class', async function (assert) {
 
 ## Linting
 
-`ember-scoped-css` exports a ember-template-lint plugin with one rule `scoped-class-helper`. This lint rule is intended to help you prevent improper use of the `scoped-class` helper which might not be immediately obvious during regular development. You can read more information in the [lint rules documentation](docs/lint-rules.md)
+`ember-scoped-css` exports a ember-template-lint plugin with one rule `scoped-class-helper`. This lint rule is intended to help you prevent improper use of the `scopedClass` helper which might not be immediately obvious during regular development. You can read more information in the [lint rules documentation](docs/lint-rules.md)
 
 ### Steps for adding the rule to the project
 
@@ -288,6 +282,7 @@ module.exports = {
   ],
   rules: {
 +    'scoped-class-helper': 'error',
++    'no-forbidden-elements': ['meta', 'html', 'script'], // style removed
   }
 
 ```

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

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

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":"AAiCA;;;;;;GAMG;AACH,mCAHW,MAAM,UAShB;AAED;;GAEG;AACH,6EAEC;AA4CD;;;;;;;;;;;;;;;;;;;;;;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,uBAmErD;AAED,8EAsCC;AAED;;;;;;GAMG;AACH,iDA+BC;AA0BD,sEAoCC;AA2BD;;;;GAIG;AACH,uCAFW,MAAM,OAyChB"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/lib/path/utils.js"],"names":[],"mappings":"AA4BA;;;;;;GAMG;AACH,mCAHW,MAAM,UAShB;AAED;;GAEG;AACH,6EAEC;AA4CD;;;;;;;;;;;;;;;;;;;;;;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,uBA0CrD;AAED,8EAsCC;AAED;;;;;;GAMG;AACH,iDAsBC;AA0BD,sEAgCC;AA2BD;;;;GAIG;AACH,uCAFW,MAAM,OAOhB"}

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

@@ -1,7 +1,4 @@
 export declare const paths: {
-    rewritten: string;
-    embroiderApp: string;
-    classicApp: string;
     v2Addon: string;
     viteApp: string;
 };

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

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

package/dist/cjs/babel-plugin.cjs

@@ -33,9 +33,6 @@ __export(babel_plugin_exports, {
   default: () => babel_plugin_default
 });
 module.exports = __toCommonJS(babel_plugin_exports);
-var import_babel_import_util = require("babel-import-util");
-var import_fs = require("fs");
-var import_path = __toESM(require("path"), 1);
 
 // src/lib/path/utils.js
 var import_node_assert = __toESM(require("node:assert"), 1);
@@ -48,59 +45,15 @@ var ourRequire = globalThis.require ? globalThis.require : here && (0, import_no
 if (!ourRequire) {
   ourRequire = require;
 }
-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", "__vite-"];
 var UNSUPPORTED_DIRECTORIES = /* @__PURE__ */ new Set(["tests"]);
 var CWD = process.cwd();
-function cssPathFor(fileName) {
-  let withoutExt = withoutExtension(fileName);
-  let cssPath = withoutExt + ".css";
-  if (isPod(fileName)) {
-    cssPath = fileName.replace(/template\.js$/, "styles.css").replace(/template\.hbs/, "styles.css");
-  }
-  return cssPath;
-}
-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 withoutExtension(filePath) {
-  let parsed = import_node_path.default.parse(filePath);
-  return import_node_path.default.join(parsed.dir, parsed.name);
-}
 function isRelevantFile(fileName, { additionalRoots, cwd }) {
+  if (fileName.startsWith("/testem")) return false;
   if (fileName.startsWith("\0")) return false;
   if (fileName.match(/^[a-zA-Z]/)) return false;
   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);
@@ -132,9 +85,6 @@ function getSeen(sourcePath) {
 }
 function findWorkspacePath(sourcePath, options) {
   let cwd = options?.cwd ?? CWD;
-  if (sourcePath.includes(EMBROIDER_3_REWRITTEN_APP_PATH)) {
-    sourcePath = sourcePath.split(EMBROIDER_3_REWRITTEN_APP_PATH)[0];
-  }
   if (sourcePath.endsWith("/")) {
     sourcePath = sourcePath.replace(/\/$/, "");
   }
@@ -190,7 +140,6 @@ var babel_plugin_default = (env, options, workingDirectory) => {
             state.canSkip = true;
             return;
           }
-          state.importUtil = new import_babel_import_util.ImportUtil(env, path2);
         }
       },
       ImportDeclaration(path2, state) {
@@ -220,27 +169,8 @@ var babel_plugin_default = (env, options, workingDirectory) => {
         if (path2.node.value.type === "Identifier" && path2.node.value.name === state.file.opts?.importedScopedClass) {
           path2.remove();
         }
-      },
-      /**
-       * If there is a CSS file, AND a corresponding template,
-       * we can import the CSS to then defer to the CSS loader
-       * or other CSS processing to handle the postfixing
-       */
-      CallExpression(path2, state) {
-        if (state.canSkip) {
-          return;
-        }
-        const node = path2.node;
-        if (node.callee.name === "precompileTemplate" || node.callee.name === "hbs" || node.callee.name === "createTemplateFactory") {
-          const fileName = state.file.opts.sourceFileName || state.file.opts.filename;
-          let cssPath = cssPathFor(fileName);
-          if ((0, import_fs.existsSync)(cssPath)) {
-            let baseCSS = import_path.default.basename(cssPath);
-            state.importUtil.importForSideEffect(`./${baseCSS}`);
-          }
-        }
       }
     }
   };
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/build/babel-plugin.js", "../../src/lib/path/utils.js"],
  "sourcesContent": ["import { ImportUtil } from 'babel-import-util';\nimport { existsSync } from 'fs';\nimport nodePath from 'path';\n\nimport { cssPathFor, isRelevantFile } from '../lib/path/utils.js';\n\nfunction _isRelevantFile(state, cwd) {\n  let fileName = state.file.opts.filename;\n  let additionalRoots = state.opts?.additionalRoots;\n\n  return isRelevantFile(fileName, {\n    additionalRoots,\n    cwd,\n  });\n}\n\n/**\n * @param {any} env - babel plugin env, env.types is most commonly used (esp in TS)\n * @param {object} options - the options for scoped-css -- this is also available in each visitor's state.opts\n * @param {string} workingDirectory\n */\nexport default (env, options, workingDirectory) => {\n  /**\n   * This babel plugin does three things:\n   * - removes the import of scopedClass, if it exists\n   *   - if scopedClass was imported, it is removed from any component's \"scope bag\"\n   *     (the scope bag being a low-level object used for passing what is \"in scope\" for a component)\n   * - adds an import to the CSS file, if it exists\n   */\n  return {\n    visitor: {\n      Program: {\n        enter(path, state) {\n          if (!_isRelevantFile(state, workingDirectory)) {\n            state.canSkip = true;\n\n            return;\n          }\n\n          state.importUtil = new ImportUtil(env, path);\n        },\n      },\n      ImportDeclaration(path, state) {\n        if (state.canSkip) {\n          return;\n        }\n\n        if (path.node.source.value === 'ember-scoped-css') {\n          let specifier = path.node.specifiers.find(\n            (x) => x.imported.name === 'scopedClass',\n          );\n\n          if (specifier) {\n            state.file.opts.importedScopedClass = specifier.local.name;\n          }\n\n          if (specifier.local.name !== 'scopedClass') {\n            throw new Error(\n              `The scopedClass import is a psuedo-helper, and may not be renamed as it is removed at build time.`,\n            );\n          }\n\n          path.remove();\n        }\n      },\n      /**\n       * Only in strict mode, do we care about remoning the scope bag reference\n       */\n      ObjectProperty(path, state) {\n        if (!state.file.opts?.importedScopedClass) return;\n\n        if (\n          path.node.value.type === 'Identifier' &&\n          path.node.value.name === state.file.opts?.importedScopedClass\n        ) {\n          path.remove();\n        }\n      },\n      /**\n       * If there is a CSS file, AND a corresponding template,\n       * we can import the CSS to then defer to the CSS loader\n       * or other CSS processing to handle the postfixing\n       */\n      CallExpression(path, state) {\n        if (state.canSkip) {\n          return;\n        }\n\n        const node = path.node;\n\n        if (\n          node.callee.name === 'precompileTemplate' ||\n          node.callee.name === 'hbs' ||\n          node.callee.name === 'createTemplateFactory'\n        ) {\n          const fileName =\n            state.file.opts.sourceFileName || state.file.opts.filename;\n\n          let cssPath = cssPathFor(fileName);\n\n          if (existsSync(cssPath)) {\n            let baseCSS = nodePath.basename(cssPath);\n\n            state.importUtil.importForSideEffect(`./${baseCSS}`);\n          }\n        }\n      },\n    },\n  };\n};\n", "import assert from 'node:assert';\nimport fsSync, { existsSync } from 'node:fs';\nimport { createRequire } from 'node:module';\nimport path from 'node:path';\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 COMPONENT_EXTENSIONS = ['.gts', '.gjs', '.ts', '.js', '.hbs'];\n\n// CJS / ESM?\nlet here = import.meta.url;\nlet ourRequire = globalThis.require\n  ? globalThis.require\n  : here && createRequire(here);\n\nif (!ourRequire) {\n  // eslint-disable-next-line no-undef\n  ourRequire = require;\n}\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', '__vite-'];\nconst UNSUPPORTED_DIRECTORIES = new Set(['tests']);\n\nconst CWD = process.cwd();\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 *\n */\nexport function cssHasAssociatedComponent(cssPath) {\n  return cssHasStandardFile(cssPath) || cssHasPodsFile(cssPath);\n}\n\nfunction cssHasStandardFile(id) {\n  /**\n   * Normally we don't need to check a JS path here, but when using\n   * embroider@3, we have a \"rewritten app\", which has all our source\n   * preprocessed a bit before scoped-css transformations.\n   *\n   * (In Vite, we operate more directly with the source)\n   */\n  for (let ext of COMPONENT_EXTENSIONS) {\n    let candidatePath = id.replace(/\\.css$/, ext);\n\n    if (existsSync(candidatePath)) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\nfunction cssHasPodsFile(id) {\n  if (!id.endsWith('styles.css')) {\n    return;\n  }\n\n  /**\n   * Normally we don't need to check a JS path here, but when using\n   * embroider@3, we have a \"rewritten app\", which has all our source\n   * preprocessed a bit before scoped-css transformations.\n   *\n   * (In Vite, we operate more directly with the source)\n   */\n  for (let ext of COMPONENT_EXTENSIONS) {\n    let candidatePath = id.replace(/styles\\.css$/, `template${ext}`);\n\n    if (existsSync(candidatePath)) {\n      return true;\n    }\n  }\n\n  return false;\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  // Private Virtual Modules\n  if (fileName.startsWith('\\0')) return false;\n  // These are not valid userland names (or are from libraries)\n  if (fileName.match(/^[a-zA-Z]/)) return false;\n  // External to us\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 = moduleName(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  // Any of the above relpacements could accidentally give us an extra / (depending on our build environment)\n  packageRelative = packageRelative.replace('//', '/');\n\n  let localPackagerStylePath = packageScopedPathToModulePath(packageRelative);\n\n  return `${name}${localPackagerStylePath}`;\n}\n\n/**\n * To avoid hitting the filesysetm, we'll store all found\n * project paths bere, so we can, in memory,\n * get the folder where a package.json exists, rather than\n * hit the file system every time.\n */\nconst SEEN = new Set();\n\nfunction getSeen(sourcePath) {\n  if (SEEN.has(sourcePath)) return sourcePath;\n\n  let parts = sourcePath.split('/');\n\n  for (let i = parts.length - 1; i > 1; i--) {\n    let toCheck = parts.slice(0, i).join('/');\n\n    let seen = SEEN.has(toCheck);\n\n    if (seen) {\n      return toCheck;\n    }\n  }\n}\n\nexport function findWorkspacePath(sourcePath, options) {\n  let cwd = options?.cwd ?? CWD;\n\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 seen = getSeen(sourcePath);\n\n  if (seen) {\n    return seen;\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 = findPackageJsonUp(sourcePath, { cwd });\n\n  if (!packageJsonPath) {\n    throw new Error(`Could not determine project for ${sourcePath}`);\n  }\n\n  const workspacePath = path.dirname(packageJsonPath);\n\n  SEEN.add(workspacePath);\n\n  return workspacePath;\n}\n\nfunction findPackageJsonUp(startPath, options) {\n  let cwd = options?.cwd ?? CWD;\n  let parts = startPath.split('/');\n\n  for (let i = parts.length - 1; i > 1; i--) {\n    let toCheck = parts.slice(0, i).join('/');\n\n    let packageJson = path.join(toCheck, 'package.json');\n    let exists = fsSync.existsSync(packageJson);\n\n    if (exists) {\n      return packageJson;\n    }\n\n    // Don't traverse all the way to the root of the file system.\n    if (toCheck === cwd) {\n      break;\n    }\n  }\n\n  return null;\n}\n\nconst MANIFEST_CACHE = new Map();\n\n/**\n * Will return the package.json#name, or config/environment#moudlePrefix (if v1 app)\n *\n * @param {string} sourcePath\n */\nexport function moduleName(sourcePath) {\n  const workspace = findWorkspacePath(sourcePath);\n  const manifest = getManifest(workspace);\n\n  if (manifest['ember-addon']) {\n    /**\n     * Libraries are not allowed to customize their module name\n     * to be different from their package name.\n     *\n     * (It's also bonkers that this is allowed for v1 apps)\n     */\n    return manifest.name;\n  }\n\n  /**\n   * For v1 apps, we need to reference the config/environment.js file\n   * to see if the modulePrefix setting differs from manifest.name;\n   */\n  let environmentJS = path.join(workspace, 'config/environment.js');\n\n  /**\n   * NOTE: the environment.js is a commonJS file, so we can synchronously require it\n   *\n   * TODO: if we have issues with loading this file later we should probably just run jscodeshift on it\n   *       but that could allow us to be brittle in different ways, like if folks stray from the way the\n   *       file is laid out from the blueprint defaults.\n   */\n  if (fsSync.existsSync(environmentJS)) {\n    // eslint-disable-next-line no-undef -- this exists\n    const envFn = ourRequire(environmentJS);\n    const env = envFn('ember-scoped-css');\n\n    return env.modulePrefix || manifest.name;\n  }\n\n  /**\n   * Fallback to the true\u2122 module\u2122 name.\n   */\n  return manifest.name;\n}\n\n/**\n * @param {string} workspace\n */\nfunction getManifest(workspace) {\n  let existing = MANIFEST_CACHE.get(workspace);\n\n  if (existing) {\n    return existing;\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;\n}\n"],
  "mappings": "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",
  "names": ["path", "assert", "path", "fsSync", "path", "nodePath"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/build/babel-plugin.js", "../../src/lib/path/utils.js"],
  "sourcesContent": ["import { isRelevantFile } from '../lib/path/utils.js';\n\nfunction _isRelevantFile(state, cwd) {\n  let fileName = state.file.opts.filename;\n  let additionalRoots = state.opts?.additionalRoots;\n\n  return isRelevantFile(fileName, {\n    additionalRoots,\n    cwd,\n  });\n}\n\n/**\n * @param {any} env - babel plugin env, env.types is most commonly used (esp in TS)\n * @param {object} options - the options for scoped-css -- this is also available in each visitor's state.opts\n * @param {string} workingDirectory\n */\nexport default (env, options, workingDirectory) => {\n  /**\n   * This babel plugin does two things:\n   * - removes the import of scopedClass, if it exists\n   *   - if scopedClass was imported, it is removed from any component's \"scope bag\"\n   *     (the scope bag being a low-level object used for passing what is \"in scope\" for a component)\n   */\n  return {\n    visitor: {\n      Program: {\n        enter(path, state) {\n          if (!_isRelevantFile(state, workingDirectory)) {\n            state.canSkip = true;\n\n            return;\n          }\n        },\n      },\n      ImportDeclaration(path, state) {\n        if (state.canSkip) {\n          return;\n        }\n\n        if (path.node.source.value === 'ember-scoped-css') {\n          let specifier = path.node.specifiers.find(\n            (x) => x.imported.name === 'scopedClass',\n          );\n\n          if (specifier) {\n            state.file.opts.importedScopedClass = specifier.local.name;\n          }\n\n          if (specifier.local.name !== 'scopedClass') {\n            throw new Error(\n              `The scopedClass import is a psuedo-helper, and may not be renamed as it is removed at build time.`,\n            );\n          }\n\n          path.remove();\n        }\n      },\n      /**\n       * Only in strict mode, do we care about remoning the scope bag reference\n       */\n      ObjectProperty(path, state) {\n        if (!state.file.opts?.importedScopedClass) return;\n\n        if (\n          path.node.value.type === 'Identifier' &&\n          path.node.value.name === state.file.opts?.importedScopedClass\n        ) {\n          path.remove();\n        }\n      },\n    },\n  };\n};\n", "import assert from 'node:assert';\nimport fsSync, { existsSync } from 'node:fs';\nimport { createRequire } from 'node:module';\nimport path from 'node:path';\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 COMPONENT_EXTENSIONS = ['.gts', '.gjs', '.ts', '.js', '.hbs'];\n\n// CJS / ESM?\nlet here = import.meta.url;\nlet ourRequire = globalThis.require\n  ? globalThis.require\n  : here && createRequire(here);\n\nif (!ourRequire) {\n  ourRequire = require;\n}\n\nconst IRRELEVANT_PATHS = ['node_modules/.pnpm', '__vite-'];\nconst UNSUPPORTED_DIRECTORIES = new Set(['tests']);\n\nconst CWD = process.cwd();\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 *\n */\nexport function cssHasAssociatedComponent(cssPath) {\n  return cssHasStandardFile(cssPath) || cssHasPodsFile(cssPath);\n}\n\nfunction cssHasStandardFile(id) {\n  /**\n   * Normally we don't need to check a JS path here, but when using\n   * embroider@3, we have a \"rewritten app\", which has all our source\n   * preprocessed a bit before scoped-css transformations.\n   *\n   * (In Vite, we operate more directly with the source)\n   */\n  for (let ext of COMPONENT_EXTENSIONS) {\n    let candidatePath = id.replace(/\\.css$/, ext);\n\n    if (existsSync(candidatePath)) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\nfunction cssHasPodsFile(id) {\n  if (!id.endsWith('styles.css')) {\n    return;\n  }\n\n  /**\n   * Normally we don't need to check a JS path here, but when using\n   * embroider@3, we have a \"rewritten app\", which has all our source\n   * preprocessed a bit before scoped-css transformations.\n   *\n   * (In Vite, we operate more directly with the source)\n   */\n  for (let ext of COMPONENT_EXTENSIONS) {\n    let candidatePath = id.replace(/styles\\.css$/, `template${ext}`);\n\n    if (existsSync(candidatePath)) {\n      return true;\n    }\n  }\n\n  return false;\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  // Fake file handled by testem server when it runs\n  if (fileName.startsWith('/testem')) return false;\n  // Private Virtual Modules\n  if (fileName.startsWith('\\0')) return false;\n  // These are not valid userland names (or are from libraries)\n  if (fileName.match(/^[a-zA-Z]/)) return false;\n  // External to us\n  if (fileName.startsWith('/@embroider')) return false;\n  if (IRRELEVANT_PATHS.some((i) => fileName.includes(i))) return false;\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 = moduleName(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  // Any of the above relpacements could accidentally give us an extra / (depending on our build environment)\n  packageRelative = packageRelative.replace('//', '/');\n\n  let localPackagerStylePath = packageScopedPathToModulePath(packageRelative);\n\n  return `${name}${localPackagerStylePath}`;\n}\n\n/**\n * To avoid hitting the filesysetm, we'll store all found\n * project paths bere, so we can, in memory,\n * get the folder where a package.json exists, rather than\n * hit the file system every time.\n */\nconst SEEN = new Set();\n\nfunction getSeen(sourcePath) {\n  if (SEEN.has(sourcePath)) return sourcePath;\n\n  let parts = sourcePath.split('/');\n\n  for (let i = parts.length - 1; i > 1; i--) {\n    let toCheck = parts.slice(0, i).join('/');\n\n    let seen = SEEN.has(toCheck);\n\n    if (seen) {\n      return toCheck;\n    }\n  }\n}\n\nexport function findWorkspacePath(sourcePath, options) {\n  let cwd = options?.cwd ?? CWD;\n\n  if (sourcePath.endsWith('/')) {\n    sourcePath = sourcePath.replace(/\\/$/, '');\n  }\n\n  let seen = getSeen(sourcePath);\n\n  if (seen) {\n    return seen;\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 = findPackageJsonUp(sourcePath, { cwd });\n\n  if (!packageJsonPath) {\n    throw new Error(`Could not determine project for ${sourcePath}`);\n  }\n\n  const workspacePath = path.dirname(packageJsonPath);\n\n  SEEN.add(workspacePath);\n\n  return workspacePath;\n}\n\nfunction findPackageJsonUp(startPath, options) {\n  let cwd = options?.cwd ?? CWD;\n  let parts = startPath.split('/');\n\n  for (let i = parts.length - 1; i > 1; i--) {\n    let toCheck = parts.slice(0, i).join('/');\n\n    let packageJson = path.join(toCheck, 'package.json');\n    let exists = fsSync.existsSync(packageJson);\n\n    if (exists) {\n      return packageJson;\n    }\n\n    // Don't traverse all the way to the root of the file system.\n    if (toCheck === cwd) {\n      break;\n    }\n  }\n\n  return null;\n}\n\nconst MANIFEST_CACHE = new Map();\n\n/**\n * Will return the package.json#name, or config/environment#moudlePrefix (if v1 app)\n *\n * @param {string} sourcePath\n */\nexport function moduleName(sourcePath) {\n  const workspace = findWorkspacePath(sourcePath);\n  const manifest = getManifest(workspace);\n\n  return manifest.name;\n}\n\n/**\n * @param {string} workspace\n */\nfunction getManifest(workspace) {\n  let existing = MANIFEST_CACHE.get(workspace);\n\n  if (existing) {\n    return existing;\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;\n}\n"],
  "mappings": "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",
  "names": ["assert", "path", "fsSync", "path"]
}
