fix: Look for broccoli tree paths in additional scopes.

Author: chriseppstein

packages/@css-blocks/ember-app/src/brocolli-plugin.ts

@@ -1,5 +1,5 @@
 import { Analyzer, Block, BlockFactory, Options as CSSBlocksOptions, SerializedSourceAnalysis, resolveConfiguration } from "@css-blocks/core";
-import { BroccoliTreeImporter, EmberAnalysis, IDENTIFIER_PREFIX as BROCCOLI_IMPORTER_IDENTIFIER_PREFIX, TEMPLATE_TYPE } from "@css-blocks/ember-support";
+import { BroccoliTreeImporter, EmberAnalysis, TEMPLATE_TYPE, pathToIdent } from "@css-blocks/ember-support";
 import { TemplateIntegrationOptions } from "@opticss/template-api";
 import mergeTrees = require("broccoli-merge-trees");
 import type { InputNode } from "broccoli-node-api";
@@ -52,7 +52,7 @@ export class CSSBlocksApplicationPlugin extends Filter {
       this.previousSourceTree = currentFSTree;
     }
     let config = resolveConfiguration(this.cssBlocksOptions);
-    let importer = new BroccoliTreeImporter(this.input, config.importer);
+    let importer = new BroccoliTreeImporter(this.input, null, config.importer);
     config = resolveConfiguration({importer}, config);
     let factory = new BlockFactory(config, postcss);
     let analyzer = new EmberAnalyzer(factory);
@@ -72,10 +72,11 @@ export class CSSBlocksApplicationPlugin extends Filter {
     };
     let optimizer = new Optimizer(optimizerOptions, analyzer.optimizationOptions);
     for (let entry of entries) {
+      let ident = pathToIdent(entry.relativePath);
       if (entry.relativePath.endsWith(".compiledblock.css")) {
         debug(`Parsing precompiled block: ${entry.relativePath}`);
         let block: Block;
-        block = await factory.getBlock(`${BROCCOLI_IMPORTER_IDENTIFIER_PREFIX}${entry.relativePath}`);
+        block = await factory.getBlock(ident);
         debug(`Got block: ${block.identifier}`);
         optimizer.addSource({
           filename: entry.relativePath,
@@ -88,7 +89,7 @@ export class CSSBlocksApplicationPlugin extends Filter {
         let serializedAnalysis: SerializedSourceAnalysis<TEMPLATE_TYPE> = JSON.parse(this.input.readFileSync(entry.relativePath, "utf8"));
         debug("blocks", serializedAnalysis.stylesFound);
         for (let blockId of Object.keys(serializedAnalysis.blocks)) {
-          serializedAnalysis.blocks[blockId] = `${BROCCOLI_IMPORTER_IDENTIFIER_PREFIX}${serializedAnalysis.blocks[blockId]}`;
+          serializedAnalysis.blocks[blockId] = pathToIdent(serializedAnalysis.blocks[blockId]);
         }
         let analysis = await EmberAnalysis.deserializeSource(serializedAnalysis, factory, analyzer);
         optimizer.addAnalysis(analysis.forOptimizer(config));

packages/@css-blocks/ember-support/src/BroccoliTreeImporter.ts

@@ -10,15 +10,39 @@ const IDENTIFIER_PREFIX_LENGTH = IDENTIFIER_PREFIX.length;
 const IDENTIFIER_PREFIX_RE = new RegExp(`^${IDENTIFIER_PREFIX}`);
 export const EMBEDDED_DEFINITION_TAG = "#blockDefinitionURL";
 
-export function isBroccoliTreeIdentifier(identifier: string | null): identifier is string {
+export function isBroccoliTreeIdentifier(identifier: string | null): boolean {
   return !!(identifier && IDENTIFIER_PREFIX_RE.test(identifier));
 }
 
-export function identToPath(identifier: string): string {
-  return identifier.substring(IDENTIFIER_PREFIX_LENGTH);
+export function identToPath(input: MergedFileSystem, identifier: string): string {
+  if (!isBroccoliTreeIdentifier(identifier)) {
+    return identifier;
+  }
+  let relativePath = identifier.substring(IDENTIFIER_PREFIX_LENGTH);
+  if (!input.existsSync(relativePath)) {
+    debug(`Couldn't find ${relativePath}. Looking in addon-tree-output.`);
+    let addonRelativePath = `addon-tree-output/${relativePath}`;
+    if (input.existsSync(addonRelativePath)) {
+      relativePath = addonRelativePath;
+    } else {
+      let addonModulesRelativePath = `addon-tree-output/modules/${relativePath}`;
+      if (input.existsSync(addonModulesRelativePath)) {
+        relativePath = addonModulesRelativePath;
+      }
+    }
+  }
+  return relativePath;
 }
 
 export function pathToIdent(relativePath: string): string {
+  if (isBroccoliTreeIdentifier(relativePath)) {
+    return relativePath;
+  }
+  if (relativePath.startsWith("addon-tree-output/modules/")) {
+    relativePath = relativePath.substring(26);
+  } else if (relativePath.startsWith("addon-tree-output/")) {
+    relativePath = relativePath.substring(18);
+  }
   return IDENTIFIER_PREFIX + relativePath;
 }
 
@@ -38,7 +62,7 @@ export class BroccoliTreeImporter extends BaseImporter {
   identifier(fromIdentifier: string | null, importPath: string, config: Readonly<Configuration>): string {
     if (isBroccoliTreeIdentifier(fromIdentifier)) {
       if (importPath.startsWith("./") || importPath.startsWith("../")) {
-        let parsedPath = path.parse(identToPath(fromIdentifier));
+        let parsedPath = path.parse(identToPath(this.input, fromIdentifier!));
         // We have to make resolve think the path is absolute or else it will
         // prepend the current working directory.
         let dir = "/" + parsedPath.dir;
@@ -55,7 +79,7 @@ export class BroccoliTreeImporter extends BaseImporter {
 
   async import(identifier: string, config: Readonly<Configuration>): Promise<ImportedFile | ImportedCompiledCssFile> {
     if (isBroccoliTreeIdentifier(identifier)) {
-      let relativePath = identToPath(identifier);
+      let relativePath = identToPath(this.input, identifier);
       let contents = this.input.readFileSync(relativePath, "utf8");
       let syntax = syntaxFromExtension(path.extname(relativePath));
       let defaultName = path.parse(relativePath).name;
@@ -111,7 +135,7 @@ export class BroccoliTreeImporter extends BaseImporter {
 
   defaultName(identifier: string, configuration: Readonly<Configuration>): string {
     if (isBroccoliTreeIdentifier(identifier)) {
-      let relativePath = identToPath(identifier);
+      let relativePath = identToPath(this.input, identifier);
       let defaultName = path.basename(relativePath);
       defaultName = defaultName.replace(/.block$/, "");
       return defaultName;
@@ -122,7 +146,7 @@ export class BroccoliTreeImporter extends BaseImporter {
 
   filesystemPath(identifier: string, config: Readonly<Configuration>): string | null {
     if (isBroccoliTreeIdentifier(identifier)) {
-      let relativePath = identToPath(identifier);
+      let relativePath = identToPath(this.input, identifier);
       return relativePath;
     } else {
       return this.fallbackImporter.filesystemPath(identifier, config);
@@ -131,7 +155,7 @@ export class BroccoliTreeImporter extends BaseImporter {
 
   debugIdentifier(identifier: string, config: Readonly<Configuration>): string {
     if (isBroccoliTreeIdentifier(identifier)) {
-      let relativePath = identToPath(identifier);
+      let relativePath = identToPath(this.input, identifier);
       return relativePath;
     } else {
       return this.fallbackImporter.debugIdentifier(identifier, config);
@@ -140,7 +164,7 @@ export class BroccoliTreeImporter extends BaseImporter {
 
   syntax(identifier: string, config: Readonly<Configuration>): Syntax {
     if (isBroccoliTreeIdentifier(identifier)) {
-      let relativePath = identToPath(identifier);
+      let relativePath = identToPath(this.input, identifier);
       let syntax = syntaxFromExtension(path.extname(relativePath));
       return syntax;
     } else {

packages/@css-blocks/ember/src/CSSBlocksTemplateCompilerPlugin.ts

@@ -9,6 +9,7 @@ import persistentStrategy = require("broccoli-persistent-filter/lib/strategies/p
 import debugGenerator from "debug";
 import TemplateCompilerPlugin = require("ember-cli-htmlbars/lib/template-compiler-plugin");
 import FSMerger = require("fs-merger");
+import type { FS as MergedFileSystem } from "fs-merger";
 import * as FSTree from "fs-tree-diff";
 import { OptiCSSOptions, postcss } from "opticss";
 import * as path from "path";
@@ -159,7 +160,7 @@ export class CSSBlocksTemplateCompilerPlugin extends TemplateCompilerPlugin {
     // we have to pre-compute the paths of all the local blocks so that we can
     // rewrite the path in the compiled output of the definition file.
     for (let block of blocks) {
-      let outputPath = getOutputPath(block);
+      let outputPath = getOutputPath(this.input, block);
       if (outputPath) blockOutputPaths.set(block, outputPath);
     }
 
@@ -328,9 +329,9 @@ function analysisPath(templatePath: string): string {
   return path.format(analysisPath);
 }
 
-function getOutputPath(block: Block): string | null {
+function getOutputPath(input: MergedFileSystem, block: Block): string | null {
   if (isBroccoliTreeIdentifier(block.identifier)) {
-    return identToPath(block.identifier).replace(".block", ".compiledblock");
+    return identToPath(input, block.identifier).replace(".block", ".compiledblock");
   } else {
     return null;
   }