chore: Code cleanup.

 - Inheritable now implements SelectorFactory
 - setBase is only available on Block objects
 - Remove LocalScope from project. Not needed after refactor.
 - Webpack loader exports as default as expected again.
 - Remove Block's internal OBJ_REF_SPLITTER path parser.
 - Remove unionInto utility from main package exports.

Author: amiller-gh

Diff for: .vscode/settings.json

@@ -1,2 +1 @@
-{
-}
+{}

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

@@ -20,28 +20,18 @@ import { OptionsReader } from "../OptionsReader";
 import { SourceLocation } from "../SourceLocation";
 import { CssBlockError, InvalidBlockSyntax } from "../errors";
 import { FileIdentifier } from "../importing";
-import { LocalScopedContext } from "../util/LocalScope";
 
 import { BlockClass } from "./BlockClass";
 import { Inheritable } from "./Inheritable";
 import { Styles } from "./Styles";
 
-export const OBJ_REF_SPLITTER = (s: string): [string, string] | undefined => {
-  let index = s.indexOf(".");
-  if (index < 0) index = s.indexOf("[");
-  if (index >= 0) {
-    return [s.substr(0, index), s.substring(index)];
-  }
-  return;
-};
-
-export class Block extends Inheritable<Block, Block, never, BlockClass> {
+export class Block
+  extends Inheritable<Block, Block, never, BlockClass> {
   private _rootClass: BlockClass;
   private _blockReferences: ObjectDictionary<Block> = {};
   private _blockReferencesReverseLookup: Map<Block, string> = new Map();
   private _identifier: FileIdentifier;
   private _implements: Block[] = [];
-  private _localScope: LocalScopedContext<Block, Styles>;
   private hasHadNameReset = false;
   /**
    * array of paths that this block depends on and, if changed, would
@@ -51,13 +41,10 @@ export class Block extends Inheritable<Block, Block, never, BlockClass> {
   private _dependencies: Set<string>;
 
   public stylesheet?: postcss.Root;
-  public readonly parsedRuleSelectors: WeakMap<postcss.Rule, ParsedSelector[]>;
 
   constructor(name: string, identifier: FileIdentifier) {
     super(name);
     this._identifier = identifier;
-    this.parsedRuleSelectors = new WeakMap();
-    this._localScope = new LocalScopedContext<Block, Styles>(OBJ_REF_SPLITTER, this);
     this._dependencies = new Set<string>();
     this._rootClass = new BlockClass(ROOT_CLASS, this);
     this.addClass(this._rootClass);
@@ -74,27 +61,16 @@ export class Block extends Inheritable<Block, Block, never, BlockClass> {
     this.hasHadNameReset = true;
   }
 
-  get rootClass(): BlockClass {
-    return this._rootClass;
-  }
-
-  /// Start of methods to implement LocalScope<Block, Style>
-  subScope(name: string): LocalScopedContext<Block, Styles> | undefined {
-    let block = this._blockReferences[name];
-    if (block) {
-      return block._localScope;
-    } else {
-      return;
-    }
+  /**
+   * Sets the base Block that this Block inherits from.
+   * @prop  base  Block  The new base Block.
+   */
+  public setBase(base: Block) {
+    this._base = base;
   }
 
-  lookupLocal(name: string): Styles | undefined {
-    let blockRef = this._blockReferences[name];
-    if (blockRef) {
-      return blockRef.rootClass;
-    } else {
-      return this.all(false).find(o => o.asSource() === name);
-    }
+  get rootClass(): BlockClass {
+    return this._rootClass;
   }
 
   /**
@@ -140,8 +116,6 @@ export class Block extends Inheritable<Block, Block, never, BlockClass> {
     return state || klass || undefined;
   }
 
-  /// End of methods to implement LocalScope<Block, Style>
-
   /**
    * Add an absolute, normalized path as a compilation dependency. This is used
    * to invalidate caches and trigger watchers when those files change.

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

@@ -43,7 +43,23 @@ export class BlockClass extends Style<BlockClass, Block, Block, StateGroup> {
     let states = group.states();
     return filter ? states.filter(s => s.name === filter) : states;
   }
+
+  /**
+   * Ensure that a `StateGroup` with the given name exists. If the `StateGroup`
+   * does not exist, it is created.
+   * @param name The State group to ensure exists.
+   * @param vallue The State's value to ensure exists.
+   * @returns The State object.
+   */
   public ensureGroup(name: string): StateGroup { return this.ensureChild(name); }
+
+  /**
+   * Ensure that a `State` within the provided group exists. If the `State`
+   * does not exist, it is created.
+   * @param name The State group to ensure exists.
+   * @param vallue The State's value to ensure exists.
+   * @returns The State object.
+   */
   public ensureState(name: string, value?: string): State {
     return this.ensureGroup(name).ensureState(value);
   }
@@ -156,16 +172,6 @@ export class BlockClass extends Style<BlockClass, Block, Block, StateGroup> {
     return result;
   }
 
-  /**
-   * Ensure that a `SubState` with the given `subStateName` exists belonging to
-   * the state named `stateName`. If the state does not exist, it is created.
-   * @param stateName The State's name to ensure.
-   * @param subStateName  Optional state group for lookup/registration
-   */
-  ensureSubState(groupName: string, subStateName: string): State {
-    return this.ensureGroup(groupName).ensureState(subStateName);
-  }
-
   /**
    * Group getter. Returns a list of State objects in the requested group that are defined
    * against this specific class. This does not take inheritance into account.

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

@@ -12,6 +12,8 @@
  * @module Block/BlockTree/Inheritable
  */
 import { ObjectDictionary } from "@opticss/util";
+import { ParsedSelector, parseSelector, SelectorFactory } from "opticss";
+import * as postcss from "postcss";
 
 /* tslint:disable:prefer-whatever-to-any */
 export type AnyNode = Inheritable<any, any, any, any>;
@@ -21,14 +23,15 @@ export abstract class Inheritable<
   Root extends Inheritable<any, Root, never, AnyNode> | Self,
   Parent extends Inheritable<any, Root, AnyNode | null, Self> | null,
   Child extends Inheritable<any, Root, Self, AnyNode | never> | never
-> {
+> implements SelectorFactory {
 /* tslint:enable:prefer-whatever-to-any */
 
   protected _name: string;
   protected _base: Self | undefined;
   protected _root: Root | Self;
   protected _parent: Parent | null;
   protected _children: Map<string, Child> = new Map();
+  private readonly parsedRuleSelectors: WeakMap<postcss.Rule, ParsedSelector[]> | null;
 
   /**
    * Given a parent that is a base class of this style, retrieve this style's
@@ -44,7 +47,10 @@ export abstract class Inheritable<
   constructor(name: string, parent?: Parent) {
     this._name = name;
     this._parent = parent || null;
-    this._root = parent ? parent.root : this.asSelf(); // `Root` is only set to `Self` for `Source` nodes.
+    // `Root` is only set to `Self` for `Source` nodes.
+    this._root = parent ? parent.root : this.asSelf();
+    // `parsedRuleSelectors cache is only created if this is a root node.
+    this.parsedRuleSelectors = this.isRootNode ? new WeakMap() : null;
   }
 
   public get name(): string { return this._name; }
@@ -87,6 +93,13 @@ export abstract class Inheritable<
     return this._root as Root;
   }
 
+  /**
+   * @returns A boolean indicating if this is the root node in the Inheritable tree or not.
+   */
+  public get isRootNode(): boolean {
+    return this._root === this.asSelf();
+  }
+
   /**
    * The `block` property is an alias for `root`. This isn't the dryest place to put
    * this line, but every extension re-declared this interface itself and I wanted it
@@ -95,14 +108,6 @@ export abstract class Inheritable<
    */
   public get block(): Root { return this.root; }
 
-  /**
-   * Sets the base node that this node inherits from. Must be of same type.
-   * @prop base The new base node.
-   */
-  public setBase(base: Self) {
-    this._base = base;
-  }
-
   /**
    * Compute all block objects that are implied by this block object through
    * inheritance. Does not include this object or the styles it implies through
@@ -172,7 +177,7 @@ export abstract class Inheritable<
     if (!this._children.has(name)) {
       this.setChild(key, this.newChild(name));
     }
-    return this._children.get(key) as Child;
+    return this._children.get(key)!;
   }
 
   /**
@@ -204,6 +209,27 @@ export abstract class Inheritable<
     return out;
   }
 
+  /**
+   * Every Block tree maintains its own local cache of parsed selectors.
+   * From any sub-inheritable, or from the root inheritable itself,
+   * given a PostCSS Rule, ensure it is present in the root Block's parsed rule
+   * selectors cache, and return the ParsedSelector array.
+   * @param rule  PostCSS Rule
+   * @return ParsedSelector array
+   */
+  public getParsedSelectors(rule: postcss.Rule): ParsedSelector[] {
+    if (!this.isRootNode) {
+      return this.root.getParsedSelectors(rule);
+    }
+
+    let selectors = this.parsedRuleSelectors!.get(rule);
+    if (!selectors) {
+      selectors = parseSelector(rule);
+      this.parsedRuleSelectors!.set(rule, selectors);
+    }
+    return selectors;
+  }
+
   // TypeScript can't figure out that `this` is the `Self` so this private
   // method casts it in a few places where it's needed.
   private asSelf(): Self {

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

@@ -10,7 +10,7 @@
  */
 import { MultiMap, TwoKeyMultiMap } from "@opticss/util";
 import * as propParser from "css-property-parser";
-import { ParsedSelector, parseSelector } from "opticss";
+import { ParsedSelector } from "opticss";
 import * as postcss from "postcss";
 
 import { BLOCK_PROP_NAMES, RESOLVE_RE, SELF_SELECTOR } from "../BlockSyntax";
@@ -115,7 +115,7 @@ export class RulesetContainer<S extends Styles> {
    */
   addRuleset(file: string, rule: postcss.Rule) {
     let style = this.parent;
-    let selectors: ParsedSelector[] = parseSelector(rule);
+    let selectors: ParsedSelector[] = style.getParsedSelectors(rule);
 
     selectors.forEach((selector) => {
       let ruleSet = new Ruleset(file, rule, style);

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

@@ -23,32 +23,77 @@ export class StateGroup extends Inheritable<StateGroup, Block, BlockClass, State
   private _universalState: State | undefined;
   private _sourceAttributes: Attr[] | undefined;
 
-  constructor(name: string, parent: BlockClass) {
-    super(name, parent);
-  }
-
   protected newChild(name: string): State { return new State(name, this); }
 
+  /**
+   * @returns If this State Group contains anything but the "Universal" State.
+   **/
   get hasSubStates(): boolean { return this._hasSubStates; }
+
+  /**
+   * @returns If this State Group only contains the "Universal" State.
+   **/
+  get isBooleanState(): boolean { return !this._hasSubStates; }
+
+  /**
+   * @returns The "Universal" State, or `undefined`.
+   **/
   get universalState(): State | undefined { return this._universalState; }
+
+  /**
+   * @returns This State's parent `BlockClass`
+   **/
   get blockClass(): BlockClass { return this.parent; }
 
+  /**
+   * @returns An array of all `State`s contained in this `StateGroup`.
+   **/
   states(): State[] { return this.children(); }
+
+  /**
+   * @returns A hash of all `State`s contained in this `StateGroup`.
+   **/
   statesHash(): ObjectDictionary<State> { return this.childrenHash(); }
+
+  /**
+   * @returns An Map of all `State`s contained in this `StateGroup`.
+   **/
   statesMap(): Map<string, State> { return this.childrenMap(); }
-  ensureState(name?: string) {
-    name = name || UNIVERSAL_STATE;
+
+  /**
+   * Ensures that a state of name `name` exists in this State group. If no
+   * `State` exists, one is created. If no name is passed, it ensures the
+   * "Universal" State.
+   * @param name  string  The `State` name to ensure.
+   * @returns The `State`
+   **/
+  ensureState(name: string = UNIVERSAL_STATE) {
     let state = this.ensureChild(name);
     if (name !== UNIVERSAL_STATE) { this._hasSubStates = true; }
     else { this._universalState = state; }
     return state;
   }
-  getState(name: string): State | null { return name ? this.getChild(name) : this.getChild(UNIVERSAL_STATE); }
-  resolveState(name: string): State | null { return name ? this.resolveChild(name) : this.resolveChild(UNIVERSAL_STATE); }
 
   /**
-   * returns whether this state has any sub states defined directly
-   * or inherited.
+   * Get a StateGroup's own (read: non-inherited) `State` of name
+   * `name` from this `StateGroup`. If no name is passed, it tries
+   * to retrieve the "Universal" State.
+   * @param name  string  The name of the `State` to retrieve.
+   * @returns The `State` or `undefined`.
+   **/
+  getState(name: string = UNIVERSAL_STATE): State | null { return this.getChild(name); }
+
+  /**
+   * Get a StateGroup's own or inherited`State` of name `name` from this
+   * `StateGroup` or its base. If no name is passed, it tries to retrieve
+   * the "Universal" State.
+   * @param name  string  The name of the `State` to retrieve.
+   * @returns The `State` or `undefined`.
+   **/
+  resolveState(name: string = UNIVERSAL_STATE): State | null { return this.resolveChild(name); }
+
+  /**
+   * @returns whether this state has any sub states defined directly or inherited.
    */
   hasResolvedStates(): boolean {
     return !!(this.hasSubStates || this.base && this.base.hasResolvedStates());
@@ -70,6 +115,9 @@ export class StateGroup extends Inheritable<StateGroup, Block, BlockClass, State
     return resolved;
   }
 
+  /**
+   * @returns The bare state selector with no qualifying `BlockClass` name.
+   */
   unqualifiedSource(value?: string): string {
     return `[state|${this.name}${(value && value !== UNIVERSAL_STATE) ? `=${value}` : ""}]`;
   }
@@ -86,6 +134,10 @@ export class StateGroup extends Inheritable<StateGroup, Block, BlockClass, State
     return (this.blockClass.isRoot ? "" : this.blockClass.asSource()) + this.unqualifiedSource(value);
   }
 
+  /**
+   * Emit analysis attributes for the `State` values this
+   * `StateGroup` represents in it's authored source format.
+   */
   asSourceAttributes(): Attr[] {
     if (!this._sourceAttributes) {
       this._sourceAttributes = [];
@@ -141,6 +193,10 @@ export class StateGroup extends Inheritable<StateGroup, Block, BlockClass, State
   }
 }
 
+/**
+ * @param o object  The object to test.
+ * @returns If the supplied object `o` is a `StateGroup`.
+ */
 export function isStateGroup(o: object): o is StateGroup {
   return o instanceof StateGroup;
 }

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

@@ -1,4 +1,4 @@
-export { Block, isBlock, OBJ_REF_SPLITTER } from "./Block";
+export { Block, isBlock } from "./Block";
 export { BlockClass, isBlockClass } from "./BlockClass";
 export { StateGroup } from "./StateGroup";
 export { State, isState } from "./State";

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

@@ -87,7 +87,7 @@ export class ConflictResolver {
         let handledObjects = new Conflicts<Style>();
 
         // For each key selector:
-        let parsedSelectors = parseSelector(rule);
+        let parsedSelectors = block.getParsedSelectors(rule);
         parsedSelectors.forEach((sel) => {
           let key = sel.key;
 
@@ -232,7 +232,7 @@ export class ConflictResolver {
     // Something to consider: when resolving against a sub-block that has overridden a property, do we need
     // to include the base object selector(s) in the key selector as well?
     let query = new QueryKeySelector(other);
-    let result = query.execute(root);
+    let result = query.execute(root, other.block);
     let foundConflict: ConflictType = ConflictType.noConflict;
     let resolvedSelectors = new Set<string>();
     curSel.forEach((cs) => {

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

@@ -1,4 +1,3 @@
-import { parseSelector } from "opticss";
 import * as postcss from "postcss";
 
 import { Block } from "../Block";
@@ -46,7 +45,7 @@ export class BlockCompiler {
       // Resolve inheritance based conflicts
       resolver.resolveInheritance(root, block);
       root.walkRules((rule) => {
-        let parsedSelectors = parseSelector(rule);
+        let parsedSelectors = block.getParsedSelectors(rule);
         rule.selector = parsedSelectors.map(s => block.rewriteSelectorToString(s, this.opts)).join(",\n");
       });
 

Diff for: packages/css-blocks/src/BlockParser/features/assert-foreign-global-state.ts

@@ -1,4 +1,3 @@
-import { parseSelector } from "opticss";
 import * as postcss from "postcss";
 
 import { Block } from "../../Block";
@@ -22,7 +21,7 @@ export async function assertForeignGlobalState(root: postcss.Root, block: Block,
 
   root.walkRules((rule) => {
 
-    let parsedSelectors = parseSelector(rule);
+    let parsedSelectors = block.getParsedSelectors(rule);
 
     parsedSelectors.forEach((iSel) => {
 

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

@@ -1,5 +1,5 @@
 import { assertNever } from "@opticss/util";
-import { CompoundSelector, ParsedSelector, parseSelector } from "opticss";
+import { CompoundSelector, ParsedSelector } from "opticss";
 import * as postcss from "postcss";
 import selectorParser = require("postcss-selector-parser");
 
@@ -35,6 +35,20 @@ function shouldBeParsedAsBlockSelector(rule: postcss.Rule): boolean {
   return !(rule.parent && rule.parent.type === "atrule" && (rule.parent).name === "keyframes");
 }
 
+/**
+ * Pull getParsedSelectors try-catch out to prevent de-opt of main walkRules function.
+ * @param block Block  The block to fetch ParsedSelectors from.
+ * @param rule  postcss.Rule  The postcss rule to parse.
+ * @param file  string  The filepath of the file we are parsing for error reporting.
+ * @returns The ParsedSelector array.
+ **/
+function getParsedSelectors(block: Block, rule: postcss.Rule, file: string): ParsedSelector[] {
+  let res;
+  try { res = block.getParsedSelectors(rule); }
+  catch (e) { throw new errors.InvalidBlockSyntax(e.message, sourceLocation(file, rule)); }
+  return res;
+}
+
 export async function constructBlock(root: postcss.Root, block: Block, file: string): Promise<Block> {
 
   let styleRuleTuples: Set<[Style, postcss.Rule]> = new Set();
@@ -46,9 +60,7 @@ export async function constructBlock(root: postcss.Root, block: Block, file: str
     if (!shouldBeParsedAsBlockSelector(rule)) { return; }
 
     // Fetch the parsed selectors list. Throw a helpful error if we can't parse.
-    let parsedSelectors;
-    try       { parsedSelectors = parseSelector(rule); }
-    catch (e) { throw new errors.InvalidBlockSyntax(e.message, sourceLocation(file, rule)); }
+    let parsedSelectors = getParsedSelectors(block, rule, file);
 
     // Iterate over the all selectors for this rule – one for each comma separated selector.
     parsedSelectors.forEach((iSel) => {
@@ -355,9 +367,9 @@ function assertBlockObject(block: Block, sel: CompoundSelector, rule: postcss.Ru
         }
       }
       return found;
-    },
+  },
     null,
-  );
+);
 
   // If no rules found in selector, we have a problem. Throw.
   if (!result) {

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

@@ -19,10 +19,9 @@ import {
 } from "@opticss/util";
 import { IdentGenerator } from "opticss";
 
-import { Block, OBJ_REF_SPLITTER, Style } from "../Block";
+import { Block, Style } from "../Block";
 import { BlockFactory } from "../BlockFactory";
 import { OptionsReader } from "../OptionsReader";
-import { CustomLocalScope } from "../util/LocalScope";
 
 import { ElementAnalysis, SerializedElementAnalysis } from "./ElementAnalysis";
 import { StyleAnalysis } from "./StyleAnalysis";
@@ -338,10 +337,14 @@ export class TemplateAnalysis<K extends keyof TemplateTypes> implements StyleAna
       blockPromises.push(promise);
     });
     return Promise.all(blockPromises).then(values => {
-      let localScope = new CustomLocalScope<Block, Style>(OBJ_REF_SPLITTER);
+
+      // Create a temporary block so we can take advantage of `Block.lookup`
+      // to easily resolve all BlockPaths referenced in the serialized analysis.
+      // TODO: We may want to abstract this so we're not making a temporary block.
+      let localScope = new Block("analysis-block", "tmp");
       values.forEach(o => {
         analysis.blocks[o.name] = o.block;
-        localScope.setSubScope(o.name, o.block);
+        localScope.addBlockReference(o.name, o.block);
       });
       let objects = new Array<Style>();
       serializedAnalysis.stylesFound.forEach(s => {

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

@@ -11,7 +11,6 @@ export * from "./importing";
 export * from "./preprocessing";
 export * from "./TemplateAnalysis";
 export * from "./TemplateRewriter";
-export * from "./util/unionInto";
 
 export {
   OptionsReader as PluginOptionsReader,

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

@@ -8,7 +8,7 @@ import {
 } from "opticss";
 import postcss = require("postcss");
 
-import { Style } from "./Block";
+import { Block, Style } from "./Block";
 
 export interface Query {
   execute(container: postcss.Container): ClassifiedParsedSelectors;
@@ -24,8 +24,7 @@ export class QueryKeySelector implements Query {
     this.impl = new QueryKeySelectorImpl(new Element(tag, attrs));
   }
 
-  // Oooohhhh I don't like this! No part of Opticss should know about css-blocks data structures.
-  execute(container: postcss.Container): ClassifiedParsedSelectors {
-    return this.impl.execute(container);
+  execute(container: postcss.Container, block?: Block): ClassifiedParsedSelectors {
+    return this.impl.execute(container, block);
   }
 }

Diff for: packages/css-blocks/src/util/LocalScope.ts

@@ -24,6 +24,9 @@ class TestSource extends Inheritable<
 > {
   protected newChild(name: string) { return new TestNode(name, this); }
   lookup(): undefined { return undefined; }
+  setBase(base: TestSource) {
+    this._base = base;
+  }
   newChildNode: RootNode["newChild"] =
     (name: string) => this.newChild(name)
 

Diff for: packages/css-blocks/test/Block/BlockTree/block-tree-test.ts

@@ -119,9 +119,9 @@ describe("Classnames Helper", () => {
   it("generates an ast fragment for a state group", () => {
     let b = new Block("test", "test");
     let r = b.rootClass;
-    let red = r.ensureSubState("theme", "red");
-    let orange = r.ensureSubState("theme", "orange");
-    let blue = r.ensureSubState("theme", "blue");
+    let red = r.ensureState("theme", "red");
+    let orange = r.ensureState("theme", "orange");
+    let blue = r.ensureState("theme", "blue");
 
     let inputs = [r, red, orange, blue];
     let rewrite = new IndexedClassMapping(inputs, [], { });
@@ -137,9 +137,9 @@ describe("Classnames Helper", () => {
   it("generates an ast fragment for a dependent state group", () => {
     let b = new Block("test", "test");
     let r = b.rootClass;
-    let red = r.ensureSubState("theme", "red");
-    let orange = r.ensureSubState("theme", "orange");
-    let blue = r.ensureSubState("theme", "blue");
+    let red = r.ensureState("theme", "red");
+    let orange = r.ensureState("theme", "orange");
+    let blue = r.ensureState("theme", "blue");
 
     let inputs = [r, red, orange, blue];
     let rewrite = new IndexedClassMapping(inputs, [], { });
@@ -302,9 +302,9 @@ describe("Classnames Helper", () => {
   it("dependent state group is allowed when class is set", () => {
     let b = new Block("test", "test");
     let r = b.rootClass;
-    let red = r.ensureSubState("theme", "red");
-    let orange = r.ensureSubState("theme", "orange");
-    let blue = r.ensureSubState("theme", "blue");
+    let red = r.ensureState("theme", "red");
+    let orange = r.ensureState("theme", "orange");
+    let blue = r.ensureState("theme", "blue");
 
     let inputs = [r, red, orange, blue];
     let rewrite = new IndexedClassMapping(inputs, [], {
@@ -329,9 +329,9 @@ describe("Classnames Helper", () => {
   it("dependent state group is disabled when class is not set", () => {
     let b = new Block("test", "test");
     let r = b.rootClass;
-    let red = r.ensureSubState("theme", "red");
-    let orange = r.ensureSubState("theme", "orange");
-    let blue = r.ensureSubState("theme", "blue");
+    let red = r.ensureState("theme", "red");
+    let orange = r.ensureState("theme", "orange");
+    let blue = r.ensureState("theme", "blue");
 
     let inputs = [r, red, orange, blue];
     let rewrite = new IndexedClassMapping(inputs, [], {
@@ -356,9 +356,9 @@ describe("Classnames Helper", () => {
   it("dependent state group is unset when falsy", () => {
     let b = new Block("test", "test");
     let r = b.rootClass;
-    let red = r.ensureSubState("theme", "red");
-    let orange = r.ensureSubState("theme", "orange");
-    let blue = r.ensureSubState("theme", "blue");
+    let red = r.ensureState("theme", "red");
+    let orange = r.ensureState("theme", "orange");
+    let blue = r.ensureState("theme", "blue");
 
     let inputs = [r, red, orange, blue];
     let rewrite = new IndexedClassMapping(inputs, [], {
@@ -383,9 +383,9 @@ describe("Classnames Helper", () => {
   it("dependent state group errors when falsy", () => {
     let b = new Block("test", "test");
     let r = b.rootClass;
-    let red = r.ensureSubState("theme", "red");
-    let orange = r.ensureSubState("theme", "orange");
-    let blue = r.ensureSubState("theme", "blue");
+    let red = r.ensureState("theme", "red");
+    let orange = r.ensureState("theme", "orange");
+    let blue = r.ensureState("theme", "blue");
 
     let inputs = [r, red, orange, blue];
     let rewrite = new IndexedClassMapping(inputs, [], {
@@ -412,9 +412,9 @@ describe("Classnames Helper", () => {
     let c1 = b.ensureClass("class-1");
     let c2 = b.ensureClass("class-2");
     let c3 = b.ensureClass("class-3");
-    let red = r.ensureSubState("theme", "red");
-    let orange = r.ensureSubState("theme", "orange");
-    let blue = r.ensureSubState("theme", "blue");
+    let red = r.ensureState("theme", "red");
+    let orange = r.ensureState("theme", "orange");
+    let blue = r.ensureState("theme", "blue");
 
     let element = new ElementAnalysis<BooleanAST, StringAST, TernaryAST>({start: POSITION_UNKNOWN});
     element.addDynamicClasses({

Diff for: packages/glimmer-templates/test/classnames-helper-test.ts

@@ -80,3 +80,7 @@ export function CSSBlocksWebpackAdapter(this: any, source: any, map: any): void
   });
 
 }
+
+// Webpack expects the default export of loaders to be the loader itself.
+// tslint:disable-next-line:no-default-export
+export default CSSBlocksWebpackAdapter;