feat(css-blocks): Don't expose generic base class methods as public.

Author: chriseppstein

packages/css-blocks/src/Block/BlockClass.ts

@@ -40,7 +40,7 @@ export class BlockClass extends StyleNode<BlockClass, Block, Block, StateGroup>
   public stateGroups(): StateGroup[] { return this.children(); }
   public resolveState(groupName: string, stateName = UNIVERSAL_STATE): State | null {
     let parent = this.resolveChild(groupName);
-    if (parent) { return parent.resolveChild(stateName); }
+    if (parent) { return parent.resolveState(stateName); }
     return null;
   }
 

packages/css-blocks/src/Block/BlockTree/Inheritable.ts

@@ -99,7 +99,7 @@ export abstract class Inheritable<
 
   /**
    * Sets the base node that this node inherits from. Must be of same type.
-   * @prop  base  Self  The new base node.
+   * @prop base The new base node.
    */
   public setBase(base: Self) {
     this._base = base;
@@ -129,7 +129,7 @@ export abstract class Inheritable<
    * @param name The name of the child to resolve.
    * @returns The child node, or `null`
    */
-  public resolveChild(name: string): Child | null {
+  protected resolveChild(name: string): Child | null {
     let state: Child | null = this.getChild(name);
     let container: Self | undefined = this.base;
     while (!state && container) {
@@ -144,7 +144,7 @@ export abstract class Inheritable<
    * @param key string  The key to fetch the child object from.
    * @returns The child node.
    */
-  public getChild(key: string): Child | null {
+  protected getChild(key: string): Child | null {
     return this._children.get(key) || null;
   }
 
@@ -153,7 +153,7 @@ export abstract class Inheritable<
    * @param key string  The key to set the child object to.
    * @returns The child node.
    */
-  public setChild(key: string, value: Child): Child {
+  protected setChild(key: string, value: Child): Child {
     this._children.set(key, value);
     return value;
   }
@@ -165,7 +165,7 @@ export abstract class Inheritable<
    * @param key string  The key at which this child object should be (optional)
    * @returns The child node.
    */
-  public ensureChild(name: string, key?: string): Child {
+  protected ensureChild(name: string, key?: string): Child {
     key = key !== undefined ? key : name;
     if (!this._children.has(name)) {
       this.setChild(key, this.newChild(name));
@@ -177,15 +177,15 @@ export abstract class Inheritable<
    * Returns an array of all children nodes in the order they were added.
    * @returns The children array.
    */
-  public children(): Child[] {
+  protected children(): Child[] {
     return [...this._children.values()];
   }
 
   /**
    * Returns a map of all children nodes at the keys they are stored..
    * @returns The children map.
    */
-  public childrenMap(): Map<string, Child> {
+  protected childrenMap(): Map<string, Child> {
     return new Map(this._children);
   }
 
@@ -194,7 +194,7 @@ export abstract class Inheritable<
    * TODO: Cache this maybe? Convert entire model to only use hash?...
    * @returns The children hash.
    */
-  public childrenHash(): ObjectDictionary<Child> {
+  protected childrenHash(): ObjectDictionary<Child> {
     let out = {};
     for (let [key, value] of this._children.entries()) {
       out[key] = value;

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

@@ -11,8 +11,31 @@ class TestSource extends SourceContainer<
   TestSource, // Self
   TestNode    // Children
 > {
-  newChild(name: string) { return new TestNode(name, this); }
+  protected newChild(name: string) { return new TestNode(name, this); }
   lookup(): undefined { return undefined; }
+  newChildNode: SourceContainer<TestSource, TestNode>['newChild'] =
+    (name: string) => this.newChild(name)
+
+  getChildNode: SourceContainer<TestSource, TestNode>['getChild'] =
+    (key: string) => this.getChild(key)
+
+  resolveChildNode: SourceContainer<TestSource, TestNode>['resolveChild'] =
+    (key: string) => this.resolveChild(key)
+
+  setChildNode: SourceContainer<TestSource, TestNode>['setChild'] =
+    (key: string, value: TestNode) => this.setChild(key, value)
+
+  ensureChildNode: SourceContainer<TestSource, TestNode>['ensureChild'] =
+    (name: string, key?: string) => this.ensureChild(name, key)
+
+  childNodes: SourceContainer<TestSource, TestNode>['children'] =
+    () => this.children()
+
+  childNodeHash: SourceContainer<TestSource, TestNode>['childrenHash'] =
+    () => this.childrenHash()
+
+  childNodeMap: SourceContainer<TestSource, TestNode>['childrenMap'] =
+    () => this.childrenMap()
 }
 
 class TestNode extends Container<
@@ -23,6 +46,12 @@ class TestNode extends Container<
 > {
   newChild(name: string) { return new TestSink(name, this); }
   lookup(): undefined { return undefined; }
+  ensureSink: Container<TestNode, TestSource, TestSource, TestSink>['ensureChild'] =
+    (name: string, key?: string) => this.ensureChild(name, key)
+  getSink: Container<TestNode, TestSource, TestSource, TestSink>['getChild'] =
+    (name: string) => this.getChild(name)
+  resolveSink: Container<TestNode, TestSource, TestSource, TestSink>['resolveChild'] =
+    (name: string) => this.resolveChild(name)
 }
 
 class TestSink extends SinkContainer<
@@ -44,58 +73,58 @@ export class BlockTreeTests {
 
   @test "newChild creates new child, does not set it"() { // Note: this is why `newChild` is protected in Blocks
     let source = new TestSource("my-source");
-    let child = source.newChild("child-node");
-    assert.equal(source.getChild("child-node"), null);
-    assert.equal(source.resolveChild("child-node"), null);
+    let child = source.newChildNode("child-node");
+    assert.equal(source.getChildNode("child-node"), null);
+    assert.equal(source.resolveChildNode("child-node"), null);
     assert.equal(child.parent, source);
     assert.equal(child.base, undefined);
     assert.equal(child.root, source);
   }
 
   @test "setChild adds new child to parent"() {
     let source = new TestSource("my-source");
-    let child = source.newChild("child-node");
-    source.setChild("child-key", child);
-    assert.equal(source.getChild("child-key"), child);
-    assert.equal(source.resolveChild("child-key"), child);
+    let child = source.newChildNode("child-node");
+    source.setChildNode("child-key", child);
+    assert.equal(source.getChildNode("child-key"), child);
+    assert.equal(source.resolveChildNode("child-key"), child);
   }
 
   @test "ensureChild creates and adds new child to parent"() {
     let source = new TestSource("my-source");
-    let child = source.ensureChild("child-node");
-    assert.equal(source.getChild("child-node"), child);
-    assert.equal(source.resolveChild("child-node"), child);
+    let child = source.ensureChildNode("child-node");
+    assert.equal(source.getChildNode("child-node"), child);
+    assert.equal(source.resolveChildNode("child-node"), child);
   }
 
   @test "ensureChild accepts optional key"() {
     let source = new TestSource("my-source");
-    let child = source.ensureChild("child-node", "child-key");
-    assert.equal(source.getChild("child-key"), child);
-    assert.equal(source.resolveChild("child-key"), child);
+    let child = source.ensureChildNode("child-node", "child-key");
+    assert.equal(source.getChildNode("child-key"), child);
+    assert.equal(source.resolveChildNode("child-key"), child);
   }
 
   @test "ensureChild will not overwrite existing nodes"() {
     let source = new TestSource("my-source");
-    let child1 = source.ensureChild("child-node");
-    let child2 = source.ensureChild("child-node");
+    let child1 = source.ensureChildNode("child-node");
+    let child2 = source.ensureChildNode("child-node");
     assert.equal(child1, child2);
   }
 
   @test "children accessor methods work as expected"() {
     let source = new TestSource("my-source");
-    let child1 = source.ensureChild("child1");
-    let child2 = source.ensureChild("child2");
-    let child3 = source.ensureChild("child3", "custom-key");
+    let child1 = source.ensureChildNode("child1");
+    let child2 = source.ensureChildNode("child2");
+    let child3 = source.ensureChildNode("child3", "custom-key");
 
-    assert.deepEqual(source.children(), [child1, child2, child3]);
-    assert.deepEqual(source.childrenHash(), {child1, child2, "custom-key": child3});
-    assert.deepEqual(source.childrenMap(), new Map([["child1", child1], ["child2", child2], ["custom-key", child3]]));
+    assert.deepEqual(source.childNodes(), [child1, child2, child3]);
+    assert.deepEqual(source.childNodeHash(), {child1, child2, "custom-key": child3});
+    assert.deepEqual(source.childNodeMap(), new Map([["child1", child1], ["child2", child2], ["custom-key", child3]]));
   }
 
   @test "grandchildren have tree properties set as expected"() {
     let source = new TestSource("my-source");
-    let child = source.ensureChild("child");
-    let grandchild = child.ensureChild("grandchild");
+    let child = source.ensureChildNode("child");
+    let grandchild = child.ensureSink("grandchild");
     assert.equal(grandchild.parent, child);
     assert.equal(grandchild.base, undefined);
     assert.equal(grandchild.root, source);
@@ -113,30 +142,30 @@ export class BlockTreeTests {
   @test "setBase creates inheritance tree for children"() {
     let base = new TestSource("my-base");
     let source = new TestSource("my-source");
-    let baseChild = base.ensureChild("child");
-    let child = source.ensureChild("child");
-    let baseUnique = base.ensureChild("base-only");
+    let baseChild = base.ensureChildNode("child");
+    let child = source.ensureChildNode("child");
+    let baseUnique = base.ensureChildNode("base-only");
     source.setBase(base);
 
     assert.equal(child.base, baseChild);
-    assert.equal(source.getChild("base-only"), null);
-    assert.equal(source.resolveChild("base-only"), baseUnique);
+    assert.equal(source.getChildNode("base-only"), null);
+    assert.equal(source.resolveChildNode("base-only"), baseUnique);
     assert.deepEqual(child.resolveInheritance(), [baseChild]);
   }
 
   @test "setBase creates inheritance tree for grandchildren"() {
     let base = new TestSource("my-base");
     let source = new TestSource("my-source");
-    let baseChild = base.ensureChild("child");
-    let baseGrandchild = baseChild.ensureChild("grandchild");
-    let baseChildUnique = baseChild.ensureChild("base-only");
-    let child = source.ensureChild("child");
-    let grandchild = child.ensureChild("grandchild");
+    let baseChild = base.ensureChildNode("child");
+    let baseGrandchild = baseChild.ensureSink("grandchild");
+    let baseChildUnique = baseChild.ensureSink("base-only");
+    let child = source.ensureChildNode("child");
+    let grandchild = child.ensureSink("grandchild");
     source.setBase(base);
 
     assert.equal(grandchild.base, baseGrandchild);
-    assert.equal(source.getChild("child")!.getChild("base-only"), null);
-    assert.equal(source.getChild("child")!.resolveChild("base-only"), baseChildUnique);
+    assert.equal(source.getChildNode("child")!.getSink("base-only"), null);
+    assert.equal(source.getChildNode("child")!.resolveSink("base-only"), baseChildUnique);
     assert.deepEqual(grandchild.resolveInheritance(), [baseGrandchild]);
   }
 }