chore: Rename variables of type ResolvedConfiguration.

Author: chriseppstein

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

@@ -78,12 +78,12 @@ export class AttrValue extends Style<AttrValue, Block, Attribute, never> {
     return this.parent.asSource(this.value);
   }
 
-  public cssClass(opts: ResolvedConfiguration): string {
-    switch (opts.outputMode) {
+  public cssClass(config: ResolvedConfiguration): string {
+    switch (config.outputMode) {
       case OutputMode.BEM:
-        return `${this.parent.cssClass(opts)}${ this.isPresenceRule ? "" : `-${this.value}`}`;
+        return `${this.parent.cssClass(config)}${ this.isPresenceRule ? "" : `-${this.value}`}`;
       default:
-        return assertNever(opts.outputMode);
+        return assertNever(config.outputMode);
     }
   }
 

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

@@ -174,16 +174,16 @@ export class Attribute extends Inheritable<Attribute, Block, BlockClass, AttrVal
 
   /**
    * Export as new class name.
-   * @param opts Option hash configuring output mode.
+   * @param config Option hash configuring output mode.
    * @returns String representing output class.
    */
-  cssClass(opts: ResolvedConfiguration) {
-    switch (opts.outputMode) {
+  cssClass(config: ResolvedConfiguration) {
+    switch (config.outputMode) {
       case OutputMode.BEM:
-        let cssClassName = this.blockClass.cssClass(opts);
+        let cssClassName = this.blockClass.cssClass(config);
         return `${cssClassName}--${this.token.name}`;
       default:
-        return assertNever(opts.outputMode);
+        return assertNever(config.outputMode);
     }
   }
 

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

@@ -367,28 +367,28 @@ export class Block
     return null;
   }
 
-  rewriteSelectorNodes(nodes: selectorParser.Node[], opts: ResolvedConfiguration): selectorParser.Node[] {
+  rewriteSelectorNodes(nodes: selectorParser.Node[], config: ResolvedConfiguration): selectorParser.Node[] {
     let newNodes: selectorParser.Node[] = [];
     for (let i = 0; i < nodes.length; i++) {
       let node = nodes[i];
       let result = this.nodeAsStyle(node);
       if (result === null) {
         newNodes.push(node);
       } else {
-        newNodes.push(selectorParser.className({ value: result[0].cssClass(opts) }));
+        newNodes.push(selectorParser.className({ value: result[0].cssClass(config) }));
         i += result[1];
       }
     }
     return newNodes;
   }
 
-  rewriteSelectorToString(selector: ParsedSelector, opts: ResolvedConfiguration): string {
+  rewriteSelectorToString(selector: ParsedSelector, config: ResolvedConfiguration): string {
     let firstNewSelector = new CompoundSelector();
     let newSelector = firstNewSelector;
     let newCurrentSelector = newSelector;
     let currentSelector: CompoundSelector | undefined = selector.selector;
     do {
-      newCurrentSelector.nodes = this.rewriteSelectorNodes(currentSelector.nodes, opts);
+      newCurrentSelector.nodes = this.rewriteSelectorNodes(currentSelector.nodes, config);
       newCurrentSelector.pseudoelement = currentSelector.pseudoelement;
       if (currentSelector.next !== undefined) {
         let tempSel = newCurrentSelector;
@@ -402,21 +402,21 @@ export class Block
     return firstNewSelector.toString();
   }
 
-  rewriteSelector(selector: ParsedSelector, opts: ResolvedConfiguration): ParsedSelector {
+  rewriteSelector(selector: ParsedSelector, config: 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);
+    let s = this.rewriteSelectorToString(selector, config);
     return parseSelector(s)[0];
   }
 
-  debug(opts: ResolvedConfiguration): string[] {
-    let result: string[] = [`Source: ${this.identifier}`, this.rootClass.asDebug(opts)];
+  debug(config: ResolvedConfiguration): string[] {
+    let result: string[] = [`Source: ${this.identifier}`, this.rootClass.asDebug(config)];
     let sourceNames = new Set<string>(this.all().map(s => s.asSource()));
     let sortedNames = [...sourceNames].sort();
     for (let n of sortedNames) {
       if (n !== ROOT_CLASS) {
         let o = this.find(n) as Styles;
-        result.push(o.asDebug(opts));
+        result.push(o.asDebug(config));
       }
     }
     return result;

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

@@ -182,19 +182,19 @@ export class BlockClass extends Style<BlockClass, Block, Block, Attribute> {
 
   /**
    * Export as new class name.
-   * @param opts Option hash configuring output mode.
+   * @param config Option hash configuring output mode.
    * @returns String representing output class.
    */
-  public cssClass(opts: ResolvedConfiguration): string {
-    switch (opts.outputMode) {
+  public cssClass(config: ResolvedConfiguration): string {
+    switch (config.outputMode) {
       case OutputMode.BEM:
         if (this.isRoot) {
           return `${this.block.name}`;
         } else {
           return `${this.block.name}__${this.name}`;
         }
       default:
-        return assertNever(opts.outputMode);
+        return assertNever(config.outputMode);
     }
   }
 
@@ -220,10 +220,10 @@ 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: ResolvedConfiguration): string[] {
+  debug(config: ResolvedConfiguration): string[] {
     let result: string[] = [];
     for (let style of this.all()) {
-      result.push(style.asDebug(opts));
+      result.push(style.asDebug(config));
     }
     return result;
   }

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

@@ -38,10 +38,10 @@ export abstract class Style<
 
   /**
    * Return the css selector for this `Style`.
-   * @param opts Option hash configuring output mode.
+   * @param config Option hash configuring output mode.
    * @returns The CSS class.
    */
-  public abstract cssClass(opts: ResolvedConfiguration): string;
+  public abstract cssClass(config: ResolvedConfiguration): string;
 
   /**
    * Return the source selector this `Style` was read from.
@@ -59,10 +59,10 @@ export abstract class Style<
    * including inherited classes.
    * @returns this object's css class and all inherited classes.
    */
-  cssClasses(opts: ResolvedConfiguration): string[] {
+  cssClasses(config: ResolvedConfiguration): string[] {
     let classes: string[] = [];
     for (let style of this.resolveStyles()) {
-      classes.push(style.cssClass(opts));
+      classes.push(style.cssClass(config));
     }
     return classes;
   }
@@ -107,11 +107,11 @@ export abstract class Style<
 
   /**
    * Debug utility to help log Styles
-   * @param opts  Options for rendering cssClass.
+   * @param config  Options for rendering cssClass.
    * @returns A debug string.
    */
-  asDebug(opts: ResolvedConfiguration) {
-    return `${this.asSource()} => ${this.cssClasses(opts).map(n => `.${n}`).join(" ")}`;
+  asDebug(config: ResolvedConfiguration) {
+    return `${this.asSource()} => ${this.cssClasses(config).map(n => `.${n}`).join(" ")}`;
   }
 
   // TypeScript can't figure out that `this` is the `StyleType` so this private

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

@@ -61,10 +61,10 @@ function updateConflict(t1: ConflictType, t2: ConflictType): ConflictType {
  * resolves property values accordingly.
  */
 export class ConflictResolver {
-  readonly opts: ResolvedConfiguration;
+  readonly config: ResolvedConfiguration;
 
-  constructor(opts: ResolvedConfiguration) {
-    this.opts = opts;
+  constructor(config: ResolvedConfiguration) {
+    this.config = config;
   }
 
   /**
@@ -242,7 +242,7 @@ export class ConflictResolver {
       // we reverse the selectors because otherwise the insertion order causes them to be backwards from the
       // source order of the target selector
       resultSelectors.reverse().forEach((s) => {
-        let newSelectors = this.mergeKeySelectors(other.block.rewriteSelector(s.parsedSelector, this.opts), cs);
+        let newSelectors = this.mergeKeySelectors(other.block.rewriteSelector(s.parsedSelector, this.config), cs);
         if (newSelectors === null) return;
         let newSelStr = newSelectors.join(",\n");
         // avoid duplicate selector via permutation
@@ -416,7 +416,7 @@ export class ConflictResolver {
     return mergedSelectors.map(sel => new ParsedSelector(sel));
   }
   sourceLocation(block: Block, node: postcss.Node): SourceLocation | undefined {
-    let blockPath = this.opts.importer.debugIdentifier(block.identifier, this.opts);
+    let blockPath = this.config.importer.debugIdentifier(block.identifier, this.config);
     return sourceLocation(blockPath, node);
   }
 }

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

@@ -18,20 +18,20 @@ import { ConflictResolver } from "./ConflictResolver";
  * interface is `BlockParser.parse`.
  */
 export class BlockCompiler {
-  private opts: ResolvedConfiguration;
+  private config: ResolvedConfiguration;
   private postcss: typeof postcss;
 
   constructor(postcssImpl: typeof postcss, opts?: SparseOptions) {
-    this.opts = normalizeOptions(opts);
+    this.config = normalizeOptions(opts);
     this.postcss = postcssImpl;
   }
 
   compile(block: Block, root: postcss.Root, analysis?: StyleAnalysis): postcss.Root {
       if (analysis) {
         // console.log("Got an analysis for compilation. I should use it probably.", analysis);
       }
-      let resolver = new ConflictResolver(this.opts);
-      let filename = this.opts.importer.debugIdentifier(block.identifier, this.opts);
+      let resolver = new ConflictResolver(this.config);
+      let filename = this.config.importer.debugIdentifier(block.identifier, this.config);
 
       // Process all debug statements for this block.
       this.processDebugStatements(filename, root, block);
@@ -53,7 +53,7 @@ export class BlockCompiler {
       resolver.resolveInheritance(root, block);
       root.walkRules((rule) => {
         let parsedSelectors = block.getParsedSelectors(rule);
-        rule.selector = parsedSelectors.map(s => block.rewriteSelectorToString(s, this.opts)).join(",\n");
+        rule.selector = parsedSelectors.map(s => block.rewriteSelectorToString(s, this.config)).join(",\n");
       });
 
       resolver.resolve(root, block);
@@ -71,7 +71,7 @@ export class BlockCompiler {
     root.walkAtRules(BLOCK_DEBUG, (atRule) => {
       let {block: ref, channel} = parseBlockDebug(atRule, sourceFile, block);
       if (channel === "comment") {
-        let debugStr = ref.debug(this.opts);
+        let debugStr = ref.debug(this.config);
         atRule.replaceWith(this.postcss.comment({text: debugStr.join("\n   ")}));
       } else {
         // stderr/stdout are emitted during parse.

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

@@ -36,7 +36,7 @@ interface ErrorWithErrNum {
 export class BlockFactory {
   postcssImpl: typeof postcss;
   importer: Importer;
-  options: ResolvedConfiguration;
+  configuration: ResolvedConfiguration;
   blockNames: ObjectDictionary<number>;
   parser: BlockParser;
   preprocessors: Preprocessors;
@@ -48,16 +48,16 @@ export class BlockFactory {
 
   constructor(options: SparseOptions, postcssImpl = postcss) {
     this.postcssImpl = postcssImpl;
-    this.options = normalizeOptions(options);
-    this.importer = this.options.importer;
-    this.preprocessors = this.options.preprocessors;
+    this.configuration = normalizeOptions(options);
+    this.importer = this.configuration.importer;
+    this.preprocessors = this.configuration.preprocessors;
     this.parser = new BlockParser(options, this);
     this.blocks = {};
     this.blockNames = {};
     this.promises = {};
     this.paths = {};
-    this.preprocessQueue = new PromiseQueue(this.options.maxConcurrentCompiles, (item: PreprocessJob) => {
-      return item.preprocessor(item.filename, item.contents, this.options);
+    this.preprocessQueue = new PromiseQueue(this.configuration.maxConcurrentCompiles, (item: PreprocessJob) => {
+      return item.preprocessor(item.filename, item.contents, this.configuration);
     });
   }
 
@@ -95,7 +95,7 @@ export class BlockFactory {
     let identifier: FileIdentifier | undefined = this.paths[filePath];
     if (identifier && this.promises[identifier]) { return this.promises[identifier]; }
 
-    identifier = identifier || this.importer.identifier(null, filePath, this.options);
+    identifier = identifier || this.importer.identifier(null, filePath, this.configuration);
     return this._getBlockPromise(identifier);
   }
 
@@ -106,13 +106,13 @@ export class BlockFactory {
 
   _getBlockPromise(identifier: FileIdentifier): Promise<Block> {
 
-    return this.promises[identifier] = this.importer.import(identifier, this.options)
+    return this.promises[identifier] = this.importer.import(identifier, this.configuration)
 
       // Parse the file into a `Block`.
       .then(file => {
 
         // If the file identifier maps back to a real filename, ensure it is actually unique.
-        let realFilename = this.importer.filesystemPath(file.identifier, this.options);
+        let realFilename = this.importer.filesystemPath(file.identifier, this.configuration);
         if (realFilename) {
           if (this.paths[realFilename] && this.paths[realFilename] !== file.identifier) {
             throw new Error(`The same block file was returned with different identifiers: ${this.paths[realFilename]} and ${file.identifier}`);
@@ -125,7 +125,7 @@ export class BlockFactory {
         if (this.blocks[file.identifier]) { return this.blocks[file.identifier]; }
 
         // Preprocess the file.
-        let filename: string = realFilename || this.importer.debugIdentifier(file.identifier, this.options);
+        let filename: string = realFilename || this.importer.debugIdentifier(file.identifier, this.configuration);
         let preprocessor = this.preprocessor(file);
         return this.preprocessQueue.enqueue({
           preprocessor,
@@ -187,8 +187,8 @@ export class BlockFactory {
 
   getBlockRelative(fromIdentifier: FileIdentifier, importPath: string): Promise<Block> {
     let importer = this.importer;
-    let fromPath = importer.debugIdentifier(fromIdentifier, this.options);
-    let identifier = importer.identifier(fromIdentifier, importPath, this.options);
+    let fromPath = importer.debugIdentifier(fromIdentifier, this.configuration);
+    let identifier = importer.identifier(fromIdentifier, importPath, this.configuration);
     return this.getBlock(identifier).catch((err: ErrorWithErrNum) => {
       if (err.code === "ENOENT") {
         err.message = `From ${fromPath}: ${err.message}`;
@@ -215,12 +215,12 @@ export class BlockFactory {
     let firstPreprocessor: Preprocessor | undefined = this.preprocessors[syntax];
     let preprocessor: Preprocessor | null = null;
     if (firstPreprocessor) {
-      if (syntax !== Syntax.css && this.preprocessors.css && !this.options.disablePreprocessChaining) {
+      if (syntax !== Syntax.css && this.preprocessors.css && !this.configuration.disablePreprocessChaining) {
         let cssProcessor = this.preprocessors.css;
-        preprocessor = (fullPath: string, content: string, options: ResolvedConfiguration): Promise<ProcessedFile> => {
-          return firstPreprocessor!(fullPath, content, options).then(result => {
+        preprocessor = (fullPath: string, content: string, configuration: ResolvedConfiguration): Promise<ProcessedFile> => {
+          return firstPreprocessor!(fullPath, content, configuration).then(result => {
             let content = result.content.toString();
-            return cssProcessor(fullPath, content, options, sourceMapFromProcessedFile(result)).then(result2 => {
+            return cssProcessor(fullPath, content, configuration, sourceMapFromProcessedFile(result)).then(result2 => {
               return {
                 content: result2.content,
                 sourceMap: sourceMapFromProcessedFile(result2),

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

@@ -32,11 +32,11 @@ export interface ParsedSource {
  * interface is `BlockParser.parse`.
  */
 export class BlockParser {
-  private opts: ResolvedConfiguration;
+  private config: ResolvedConfiguration;
   private factory: BlockFactory;
 
   constructor(opts: SparseOptions, factory: BlockFactory) {
-    this.opts = normalizeOptions(opts);
+    this.config = normalizeOptions(opts);
     this.factory = factory;
   }
 
@@ -60,9 +60,9 @@ export class BlockParser {
    * @param defaultName Name of block
    */
   public async parse(root: postcss.Root, identifier: string, name: string): Promise<Block> {
-    let importer = this.opts.importer;
-    let debugIdent = importer.debugIdentifier(identifier, this.opts);
-    let sourceFile = importer.filesystemPath(identifier, this.opts) || debugIdent;
+    let importer = this.config.importer;
+    let debugIdent = importer.debugIdentifier(identifier, this.config);
+    let sourceFile = importer.filesystemPath(identifier, this.config) || debugIdent;
 
     // Discover the block's preferred name.
     name = await discoverName(root, name, sourceFile);
@@ -86,7 +86,7 @@ export class BlockParser {
     // Validate that all required Styles are implemented.
     await implementBlock(root, block, debugIdent);
     // Log any debug statements discovered.
-    await processDebugStatements(root, block, debugIdent, this.opts);
+    await processDebugStatements(root, block, debugIdent, this.config);
 
     // Return our fully constructed block.
     return block;

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

@@ -11,10 +11,10 @@ import { ResolvedConfiguration } from "../../options";
  * @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: ResolvedConfiguration) {
+export async function processDebugStatements(root: postcss.Root, block: Block, file: string, config: ResolvedConfiguration) {
   root.walkAtRules(BLOCK_DEBUG, (atRule) => {
     let { block: ref, channel } = parseBlockDebug(atRule, file, block);
-    let debugStr = ref.debug(opts);
+    let debugStr = ref.debug(config);
     if (channel !== "comment") {
       if (channel === "stderr") {
         console.warn(debugStr.join("\n"));