feat: Rename ReadonlyOptions to ResolvedConfiguration.

BREAKING CHANGE:

ReadonlyOptions is really the configuration after having been fully
resolved and populated by defaults.  So the name ResolvedConfiguration
makes more sense. This is the second of several commits to rename
the types for our options.

Author: chriseppstein

Diff for: packages/css-blocks/src/Block/AttrValue.ts

@@ -8,7 +8,7 @@ import { assertNever, assertNeverCalled } from "@opticss/util";
 
 import { ATTR_PRESENT } from "../BlockSyntax";
 import { OutputMode } from "../OutputMode";
-import { ReadonlyOptions } from "../options";
+import { ResolvedConfiguration } from "../options";
 
 import { Attribute } from "./Attribute";
 import { Block } from "./Block";
@@ -78,7 +78,7 @@ export class AttrValue extends Style<AttrValue, Block, Attribute, never> {
     return this.parent.asSource(this.value);
   }
 
-  public cssClass(opts: ReadonlyOptions): string {
+  public cssClass(opts: ResolvedConfiguration): string {
     switch (opts.outputMode) {
       case OutputMode.BEM:
         return `${this.parent.cssClass(opts)}${ this.isPresenceRule ? "" : `-${this.value}`}`;

Diff for: packages/css-blocks/src/Block/Attribute.ts

@@ -10,7 +10,7 @@ import { assertNever, ObjectDictionary } from "@opticss/util";
 
 import { ATTR_PRESENT, IAttrToken as AttrToken } from "../BlockSyntax";
 import { OutputMode } from "../OutputMode";
-import { ReadonlyOptions } from "../options";
+import { ResolvedConfiguration } from "../options";
 
 import { AttrValue } from "./AttrValue";
 import { Block } from "./Block";
@@ -177,7 +177,7 @@ export class Attribute extends Inheritable<Attribute, Block, BlockClass, AttrVal
    * @param opts Option hash configuring output mode.
    * @returns String representing output class.
    */
-  cssClass(opts: ReadonlyOptions) {
+  cssClass(opts: ResolvedConfiguration) {
     switch (opts.outputMode) {
       case OutputMode.BEM:
         let cssClassName = this.blockClass.cssClass(opts);

Diff for: packages/css-blocks/src/Block/Block.ts

@@ -19,7 +19,7 @@ import { BlockPath, CLASS_NAME_IDENT, ROOT_CLASS } from "../BlockSyntax";
 import { SourceLocation } from "../SourceLocation";
 import { CssBlockError, InvalidBlockSyntax } from "../errors";
 import { FileIdentifier } from "../importing";
-import { ReadonlyOptions } from "../options";
+import { ResolvedConfiguration } from "../options";
 
 import { BlockClass } from "./BlockClass";
 import { Inheritable } from "./Inheritable";
@@ -367,7 +367,7 @@ export class Block
     return null;
   }
 
-  rewriteSelectorNodes(nodes: selectorParser.Node[], opts: ReadonlyOptions): selectorParser.Node[] {
+  rewriteSelectorNodes(nodes: selectorParser.Node[], opts: ResolvedConfiguration): selectorParser.Node[] {
     let newNodes: selectorParser.Node[] = [];
     for (let i = 0; i < nodes.length; i++) {
       let node = nodes[i];
@@ -382,7 +382,7 @@ export class Block
     return newNodes;
   }
 
-  rewriteSelectorToString(selector: ParsedSelector, opts: ReadonlyOptions): string {
+  rewriteSelectorToString(selector: ParsedSelector, opts: ResolvedConfiguration): string {
     let firstNewSelector = new CompoundSelector();
     let newSelector = firstNewSelector;
     let newCurrentSelector = newSelector;
@@ -402,14 +402,14 @@ export class Block
     return firstNewSelector.toString();
   }
 
-  rewriteSelector(selector: ParsedSelector, opts: ReadonlyOptions): ParsedSelector {
+  rewriteSelector(selector: ParsedSelector, opts: ResolvedConfiguration): ParsedSelector {
     // generating a string and re-parsing ensures the internal structure is consistent
     // otherwise the parent/next/prev relationships will be wonky with the new nodes.
     let s = this.rewriteSelectorToString(selector, opts);
     return parseSelector(s)[0];
   }
 
-  debug(opts: ReadonlyOptions): string[] {
+  debug(opts: ResolvedConfiguration): string[] {
     let result: string[] = [`Source: ${this.identifier}`, this.rootClass.asDebug(opts)];
     let sourceNames = new Set<string>(this.all().map(s => s.asSource()));
     let sortedNames = [...sourceNames].sort();

Diff for: packages/css-blocks/src/Block/BlockClass.ts

@@ -1,10 +1,11 @@
 import { Attribute as Attr, AttributeValue, attrValues } from "@opticss/element-analysis";
+import { assertNever } from "@opticss/util";
 import { isString } from "util";
 
 import { ATTR_PRESENT, IAttrToken as AttrToken, ROOT_CLASS } from "../BlockSyntax";
 import { BlockPath } from "../BlockSyntax";
 import { OutputMode } from "../OutputMode";
-import { ReadonlyOptions } from "../options";
+import { ResolvedConfiguration } from "../options";
 
 import { AttrValue } from "./AttrValue";
 import { Attribute } from "./Attribute";
@@ -184,7 +185,7 @@ export class BlockClass extends Style<BlockClass, Block, Block, Attribute> {
    * @param opts Option hash configuring output mode.
    * @returns String representing output class.
    */
-  public cssClass(opts: ReadonlyOptions): string {
+  public cssClass(opts: ResolvedConfiguration): string {
     switch (opts.outputMode) {
       case OutputMode.BEM:
         if (this.isRoot) {
@@ -193,7 +194,7 @@ export class BlockClass extends Style<BlockClass, Block, Block, Attribute> {
           return `${this.block.name}__${this.name}`;
         }
       default:
-        throw new Error("this never happens");
+        return assertNever(opts.outputMode);
     }
   }
 
@@ -219,7 +220,7 @@ export class BlockClass extends Style<BlockClass, Block, Block, Attribute> {
    * @param options  Options to pass to BlockClass' asDebug method.
    * @return Array of debug strings for this BlockClass
    */
-  debug(opts: ReadonlyOptions): string[] {
+  debug(opts: ResolvedConfiguration): string[] {
     let result: string[] = [];
     for (let style of this.all()) {
       result.push(style.asDebug(opts));

Diff for: packages/css-blocks/src/Block/Style.ts

@@ -1,6 +1,6 @@
 import { Attr } from "@opticss/element-analysis";
 
-import { ReadonlyOptions } from "../options";
+import { ResolvedConfiguration } from "../options";
 import { unionInto } from "../util/unionInto";
 
 import { AnyNode, Inheritable } from "./Inheritable";
@@ -41,7 +41,7 @@ export abstract class Style<
    * @param opts Option hash configuring output mode.
    * @returns The CSS class.
    */
-  public abstract cssClass(opts: ReadonlyOptions): string;
+  public abstract cssClass(opts: ResolvedConfiguration): string;
 
   /**
    * Return the source selector this `Style` was read from.
@@ -59,7 +59,7 @@ export abstract class Style<
    * including inherited classes.
    * @returns this object's css class and all inherited classes.
    */
-  cssClasses(opts: ReadonlyOptions): string[] {
+  cssClasses(opts: ResolvedConfiguration): string[] {
     let classes: string[] = [];
     for (let style of this.resolveStyles()) {
       classes.push(style.cssClass(opts));
@@ -110,7 +110,7 @@ export abstract class Style<
    * @param opts  Options for rendering cssClass.
    * @returns A debug string.
    */
-  asDebug(opts: ReadonlyOptions) {
+  asDebug(opts: ResolvedConfiguration) {
     return `${this.asSource()} => ${this.cssClasses(opts).map(n => `.${n}`).join(" ")}`;
   }
 

Diff for: packages/css-blocks/src/BlockCompiler/ConflictResolver.ts

@@ -8,7 +8,7 @@ import { getBlockNode } from "../BlockParser";
 import { RESOLVE_RE } from "../BlockSyntax";
 import { SourceLocation, sourceLocation } from "../SourceLocation";
 import * as errors from "../errors";
-import { ReadonlyOptions } from "../options";
+import { ResolvedConfiguration } from "../options";
 import { QueryKeySelector } from "../query";
 
 import { Conflicts, detectConflicts } from "./conflictDetection";
@@ -61,9 +61,9 @@ function updateConflict(t1: ConflictType, t2: ConflictType): ConflictType {
  * resolves property values accordingly.
  */
 export class ConflictResolver {
-  readonly opts: ReadonlyOptions;
+  readonly opts: ResolvedConfiguration;
 
-  constructor(opts: ReadonlyOptions) {
+  constructor(opts: ResolvedConfiguration) {
     this.opts = opts;
   }
 

Diff for: packages/css-blocks/src/BlockCompiler/index.ts

@@ -10,15 +10,15 @@ import {
 } from "../BlockSyntax";
 import { StyleAnalysis } from "../TemplateAnalysis/StyleAnalysis";
 import { normalizeOptions } from "../normalizeOptions";
-import { ReadonlyOptions, SparseOptions } from "../options";
+import { ResolvedConfiguration, SparseOptions } from "../options";
 
 import { ConflictResolver } from "./ConflictResolver";
 /**
  * Compiler that, given a Block will return a transformed AST
  * interface is `BlockParser.parse`.
  */
 export class BlockCompiler {
-  private opts: ReadonlyOptions;
+  private opts: ResolvedConfiguration;
   private postcss: typeof postcss;
 
   constructor(postcssImpl: typeof postcss, opts?: SparseOptions) {

Diff for: packages/css-blocks/src/BlockParser/BlockFactory.ts

@@ -7,7 +7,7 @@ import { RawSourceMap } from "source-map";
 import { Block } from "../Block";
 import { FileIdentifier, ImportedFile, Importer } from "../importing";
 import { normalizeOptions } from "../normalizeOptions";
-import { ReadonlyOptions, SparseOptions } from "../options";
+import { ResolvedConfiguration, SparseOptions } from "../options";
 import { PromiseQueue } from "../util/PromiseQueue";
 
 import { BlockParser, ParsedSource } from "./BlockParser";
@@ -36,7 +36,7 @@ interface ErrorWithErrNum {
 export class BlockFactory {
   postcssImpl: typeof postcss;
   importer: Importer;
-  options: ReadonlyOptions;
+  options: ResolvedConfiguration;
   blockNames: ObjectDictionary<number>;
   parser: BlockParser;
   preprocessors: Preprocessors;
@@ -217,7 +217,7 @@ export class BlockFactory {
     if (firstPreprocessor) {
       if (syntax !== Syntax.css && this.preprocessors.css && !this.options.disablePreprocessChaining) {
         let cssProcessor = this.preprocessors.css;
-        preprocessor = (fullPath: string, content: string, options: ReadonlyOptions): Promise<ProcessedFile> => {
+        preprocessor = (fullPath: string, content: string, options: ResolvedConfiguration): Promise<ProcessedFile> => {
           return firstPreprocessor!(fullPath, content, options).then(result => {
             let content = result.content.toString();
             return cssProcessor(fullPath, content, options, sourceMapFromProcessedFile(result)).then(result2 => {
@@ -235,7 +235,7 @@ export class BlockFactory {
     } else if (syntax !== Syntax.css) {
       throw new Error(`No preprocessor provided for ${syntaxName(syntax)}.`);
     } else {
-      preprocessor = (_fullPath: string, content: string, _options: ReadonlyOptions): Promise<ProcessedFile> => {
+      preprocessor = (_fullPath: string, content: string, _options: ResolvedConfiguration): Promise<ProcessedFile> => {
         return Promise.resolve({
           content: content,
         });

Diff for: packages/css-blocks/src/BlockParser/BlockParser.ts

@@ -4,7 +4,7 @@ import { Block } from "../Block";
 import * as errors from "../errors";
 import { FileIdentifier } from "../importing";
 import { normalizeOptions } from "../normalizeOptions";
-import { ReadonlyOptions, SparseOptions } from "../options";
+import { ResolvedConfiguration, SparseOptions } from "../options";
 
 import { assertForeignGlobalAttribute } from "./features/assert-foreign-global-attribute";
 import { constructBlock } from "./features/construct-block";
@@ -32,7 +32,7 @@ export interface ParsedSource {
  * interface is `BlockParser.parse`.
  */
 export class BlockParser {
-  private opts: ReadonlyOptions;
+  private opts: ResolvedConfiguration;
   private factory: BlockFactory;
 
   constructor(opts: SparseOptions, factory: BlockFactory) {

Diff for: packages/css-blocks/src/BlockParser/features/process-debug-statements.ts

@@ -3,15 +3,15 @@ import * as postcss from "postcss";
 
 import { Block } from "../../Block";
 import { BLOCK_DEBUG, parseBlockDebug } from "../../BlockSyntax";
-import { ReadonlyOptions } from "../../options";
+import { ResolvedConfiguration } from "../../options";
 
 /**
  * Process all `@block-debug` statements, output debug statement to console or in comment as requested.
  * @param sourceFile File name of block in question.
  * @param root PostCSS Root for block.
  * @param block Block to resolve references for
  */
-export async function processDebugStatements(root: postcss.Root, block: Block, file: string, opts: ReadonlyOptions) {
+export async function processDebugStatements(root: postcss.Root, block: Block, file: string, opts: ResolvedConfiguration) {
   root.walkAtRules(BLOCK_DEBUG, (atRule) => {
     let { block: ref, channel } = parseBlockDebug(atRule, file, block);
     let debugStr = ref.debug(opts);

Diff for: packages/css-blocks/src/BlockParser/preprocessing.ts

@@ -5,7 +5,7 @@ import {
 } from "source-map";
 
 import {
-  ReadonlyOptions,
+  ResolvedConfiguration,
 } from "../options";
 
 export enum Syntax {
@@ -41,7 +41,7 @@ export interface ProcessedFile {
 }
 
 // export type ContentPreprocessor = (content: string) => Promise<ProcessedFile>;
-export type Preprocessor = (fullPath: string, content: string, options: ReadonlyOptions, sourceMap?: RawSourceMap | string) => Promise<ProcessedFile>;
+export type Preprocessor = (fullPath: string, content: string, options: ResolvedConfiguration, sourceMap?: RawSourceMap | string) => Promise<ProcessedFile>;
 
 /**
  * A map of supported syntaxes to the preprocessor function for that syntax.

Diff for: packages/css-blocks/src/Plugin.ts

@@ -4,14 +4,14 @@ import { BlockCompiler } from "./BlockCompiler";
 import { BlockFactory } from "./BlockParser";
 import * as errors from "./errors";
 import { normalizeOptions } from "./normalizeOptions";
-import { ReadonlyOptions, SparseOptions } from "./options";
+import { ResolvedConfiguration, SparseOptions } from "./options";
 export { SparseOptions } from "./options";
 
 /**
  * CSS Blocks PostCSS plugin.
  */
 export class Plugin {
-  private opts: ReadonlyOptions;
+  private opts: ResolvedConfiguration;
   private postcss: typeof postcss;
 
   /**

Diff for: packages/css-blocks/src/TemplateAnalysis/ElementAnalysis.ts

@@ -30,7 +30,7 @@ import {
   Style,
 } from "../Block";
 import {
-  ReadonlyOptions,
+  ResolvedConfiguration,
 } from "../options";
 import {
   unionInto,
@@ -606,7 +606,7 @@ export class ElementAnalysis<BooleanExpression, StringExpression, TernaryExpress
    * assumed to be unique per Style across all blocks -- so these
    * maps can be merged safely.
    */
-  forOptimizer(options: ReadonlyOptions): [Element, Map<string, Style>] {
+  forOptimizer(options: ResolvedConfiguration): [Element, Map<string, Style>] {
     this.assertSealed();
     let tagValue = this.tagName ? attrValues.constant(this.tagName) : attrValues.unknown();
     let tagName = new Tagname(tagValue);
@@ -770,7 +770,7 @@ function addToSet(
 
 type ClassMapper = (style: Style) => ValueConstant | AttributeValueSet;
 function mapClasses(
-  options: ReadonlyOptions,
+  options: ResolvedConfiguration,
   map: Map<string, Style>,
   style: Style,
 ): ValueConstant | AttributeValueSet {
@@ -790,7 +790,7 @@ function mapClasses(
 
 type ChoiceMapper = (includeAbsent: boolean, ...styles: Style[]) => AttributeValueChoice;
 function mapChoiceClasses(
-  options: ReadonlyOptions,
+  options: ResolvedConfiguration,
   map: Map<string, Style>,
   includeAbsent: boolean,
   ...styles: Style[],

Diff for: packages/css-blocks/src/TemplateAnalysis/MetaAnalysis.ts

@@ -7,7 +7,7 @@ import { whatever } from "@opticss/util";
 import * as debugGenerator from "debug";
 
 import { Block, Style } from "../Block";
-import { ReadonlyOptions } from "../options";
+import { ResolvedConfiguration } from "../options";
 
 import { StyleAnalysis } from "./StyleAnalysis";
 import { SerializedTemplateAnalysis, TemplateAnalysis } from "./index";
@@ -108,7 +108,7 @@ export class MetaTemplateAnalysis implements StyleAnalysis {
     return { analyses };
   }
 
-  forOptimizer(opts: ReadonlyOptions): Array<OptimizedTemplateAnalysis<keyof TemplateTypes>> {
+  forOptimizer(opts: ResolvedConfiguration): Array<OptimizedTemplateAnalysis<keyof TemplateTypes>> {
     let analyses = new Array<OptimizedTemplateAnalysis<keyof TemplateTypes>>();
     this.eachAnalysis(a => {
       analyses.push(a.forOptimizer(opts));

Diff for: packages/css-blocks/src/TemplateAnalysis/TemplateAnalysis.ts

@@ -21,7 +21,7 @@ import { IdentGenerator } from "opticss";
 
 import { Block, Style } from "../Block";
 import { BlockFactory } from "../BlockParser";
-import { ReadonlyOptions } from "../options";
+import { ResolvedConfiguration } from "../options";
 
 import { ElementAnalysis, SerializedElementAnalysis } from "./ElementAnalysis";
 import { StyleAnalysis } from "./StyleAnalysis";
@@ -368,7 +368,7 @@ export class TemplateAnalysis<K extends keyof TemplateTypes> implements StyleAna
     });
   }
 
-  forOptimizer(opts: ReadonlyOptions): OptimizationTemplateAnalysis<K> {
+  forOptimizer(opts: ResolvedConfiguration): OptimizationTemplateAnalysis<K> {
     let optAnalysis = new OptimizationTemplateAnalysis<K>(this.template);
     for (let element of this.elements.values()) {
       let result = element.forOptimizer(opts);

Diff for: packages/css-blocks/src/TemplateRewriter/StyleMapping.ts

@@ -3,7 +3,7 @@ import { StyleMapping as OptimizedMapping, TemplateTypes } from "@opticss/templa
 import { Block, Style } from "../Block";
 import { TemplateAnalysis } from "../TemplateAnalysis";
 import { ElementAnalysis } from "../TemplateAnalysis/ElementAnalysis";
-import { ReadonlyOptions } from "../options";
+import { ResolvedConfiguration } from "../options";
 
 import { IndexedClassRewrite } from "./ClassRewrite";
 import { IndexedClassMapping, RewriteMapping } from "./RewriteMapping";
@@ -12,13 +12,13 @@ export class StyleMapping {
   analyses: Array<TemplateAnalysis<keyof TemplateTypes>> | undefined;
   /** The blocks that were used to create this mapping. */
   blocks: Set<Block>;
-  private options: ReadonlyOptions;
+  private options: ResolvedConfiguration;
   private optimizedMap: OptimizedMapping;
 
   constructor(
     optimizedMap: OptimizedMapping,
     blocks: Iterable<Block>,
-    options: ReadonlyOptions,
+    options: ResolvedConfiguration,
     analyses?: Array<TemplateAnalysis<keyof TemplateTypes>>,
   ) {
     this.options = options;