feat: Add BlockCompiler method for compiling a definition file.

Author: chriseppstein

packages/@css-blocks/core/src/BlockCompiler/BlockDefinitionCompiler.ts

@@ -0,0 +1,26 @@
+import { postcss } from "opticss";
+
+import { Block } from "../BlockTree";
+import { ResolvedConfiguration } from "../configuration";
+
+export const INLINE_DEFINITION_FILE = Symbol("Inline Definition");
+export class BlockDefinitionCompiler {
+  postcss: typeof postcss;
+  config: ResolvedConfiguration;
+  constructor(postcssImpl: typeof postcss, config: ResolvedConfiguration) {
+    this.postcss = postcssImpl;
+    this.config = config;
+  }
+
+  compile(_block: Block): postcss.Root {
+    throw new Error("Method not implemented.");
+    // return postcss.root();
+  }
+
+  insertReference(_css: postcss.Root, _definitionPath: string) {
+    throw new Error("Method not implemented.");
+  }
+  insertInlineReference(_css: postcss.Root, _definition: postcss.Root) {
+    throw new Error("Method not implemented.");
+  }
+}

packages/@css-blocks/core/src/BlockCompiler/index.ts

@@ -15,18 +15,68 @@ import {
   resolveConfiguration,
 } from "../configuration";
 
+import { BlockDefinitionCompiler, INLINE_DEFINITION_FILE } from "./BlockDefinitionCompiler";
 import { ConflictResolver } from "./ConflictResolver";
+
+export { INLINE_DEFINITION_FILE } from "./BlockDefinitionCompiler";
+
+export interface CompiledBlockAndDefinition {
+  definitionPath: string;
+  css: postcss.Root;
+  definition: postcss.Root;
+}
+
+export interface CompiledBlockAndInlineDefinition {
+  definitionPath: typeof INLINE_DEFINITION_FILE;
+  css: postcss.Root;
+}
+
 /**
  * Compiler that, given a Block will return a transformed AST
  * interface is `BlockParser.parse`.
  */
 export class BlockCompiler {
   private config: ResolvedConfiguration;
   private postcss: typeof postcss;
+  private definitionCompiler: BlockDefinitionCompiler;
 
   constructor(postcssImpl: typeof postcss, opts?: Options) {
     this.config = resolveConfiguration(opts);
     this.postcss = postcssImpl;
+    this.definitionCompiler = new BlockDefinitionCompiler(postcssImpl, this.config);
+  }
+
+  compileWithDefinition(block: Block, root: postcss.Root, reservedClassNames: Set<string>, definitionPath: typeof INLINE_DEFINITION_FILE): CompiledBlockAndInlineDefinition;
+  compileWithDefinition(block: Block, root: postcss.Root, reservedClassNames: Set<string>, definitionPath: string): CompiledBlockAndDefinition;
+  compileWithDefinition(block: Block, root: postcss.Root, reservedClassNames: Set<string>, definitionPath: string | typeof INLINE_DEFINITION_FILE): CompiledBlockAndDefinition | CompiledBlockAndInlineDefinition {
+    let css = this.compile(block, root, reservedClassNames);
+    let definition = this.definitionCompiler.compile(block);
+    let result: CompiledBlockAndDefinition | CompiledBlockAndInlineDefinition;
+
+    if (definitionPath === INLINE_DEFINITION_FILE) {
+      this.definitionCompiler.insertInlineReference(css, definition);
+      result = {
+        definitionPath,
+        css,
+      };
+    } else {
+      this.definitionCompiler.insertReference(css, definitionPath);
+      result = {
+        definitionPath,
+        css,
+        definition,
+      };
+    }
+
+    let startComment = postcss.comment({text: `#css-blocks ${block.guid}`});
+    startComment.raws.after = "\n";
+    css.prepend(startComment);
+
+    let endComment = postcss.comment({text: `#css-blocks end`});
+    endComment.raws.after = "\n";
+    css.append(endComment);
+
+    return result;
   }
 
   compile(block: Block, root: postcss.Root, reservedClassNames: Set<string>): postcss.Root {