Merge pull request #13 from simon360/feat/rename-for-consistency

Rename main exports for consistency

Author: simon360

packages/class-references/README.md

@@ -23,30 +23,30 @@ yarn add class-references
 Any time you want to add a class (eg. `MyClassName`) to an element (eg. `document.body`), use:
 
 ```js
-import { claimForClass } from "class-references";
+import { requestTokenForClass } from "class-references";
 
-const token = claimForClass(document.body, "MyClassName");
+const token = requestTokenForClass(document.body, "MyClassName");
 ```
 
 When you're ready to remove the class, make sure you can recall the token, and use:
 
 ```js
-import { release } from "class-references";
+import { releaseToken } from "class-references";
 
-release(document.body, token);
+releaseToken(document.body, token);
 ```
 
 ### Advanced examples
 
 ```js
-import { claimForClass, release } from "class-references";
+import { releaseToken, requestTokenForClass } from "class-references";
 
 const className = "u-preventScroll";
 const element = document.body;
 
-const token1 = claimForClass(element, className); // Class is added
-const token2 = claimForClass(element, className); // Class was already added, but another token reserves it.
+const token1 = requestTokenForClass(element, className); // Class is added
+const token2 = requestTokenForClass(element, className); // Class was already added, but another token reserves it.
 
-release(element, token1); // token1 is released; token2 not released, class remains
-release(element, token2); // both tokens are released, class removed
+releaseToken(element, token1); // token1 is released; token2 not released, class remains
+releaseToken(element, token2); // both tokens are released, class removed
 ```

packages/class-references/__tests__/tests-index.ts

@@ -1,7 +1,7 @@
 import { getClassReferences } from "../src/element";
-import { claimForClass, release } from "../src/index";
+import { releaseToken, requestTokenForClass } from "../src/index";
 import {
-  newObjectWithoutReferenceToId,
+  newObjectWithoutReferenceToToken,
   newObjectWithReferenceToClass
 } from "../src/referenceObject";
 
@@ -20,14 +20,14 @@ describe("index", () => {
   beforeEach(() => {
     (getClassReferences as any).mockReturnValue(fakeReferences);
     (newObjectWithReferenceToClass as any).mockReturnValue(fakeReferences);
-    (newObjectWithoutReferenceToId as any).mockReturnValue(fakeReferences);
+    (newObjectWithoutReferenceToToken as any).mockReturnValue(fakeReferences);
 
     element = document.createElement("div");
   });
 
   describe("claimForClass()", () => {
     it("should add the class to the element's class list", () => {
-      claimForClass(element, testClassName);
+      requestTokenForClass(element, testClassName);
 
       expect(element.classList.contains(testClassName)).toBe(true);
     });
@@ -39,13 +39,13 @@ describe("index", () => {
         lastToken: token
       });
 
-      expect(claimForClass(element, testClassName)).toBe(token);
+      expect(requestTokenForClass(element, testClassName)).toBe(token);
     });
   });
 
   describe("release()", () => {
     it("should remove classes when all tokens are released", () => {
-      (newObjectWithoutReferenceToId as any).mockReturnValue({
+      (newObjectWithoutReferenceToToken as any).mockReturnValue({
         classes: {
           [testClassName]: []
         },
@@ -54,13 +54,13 @@ describe("index", () => {
 
       element.classList.add(testClassName);
 
-      release(element, 142); // actual token is irrelevant; mock takes care of it
+      releaseToken(element, 142); // actual token is irrelevant; mock takes care of it
 
       expect(element.classList.contains(testClassName)).toBe(false);
     });
 
     it("should not remove classes where tokens remain", () => {
-      (newObjectWithoutReferenceToId as any).mockReturnValue({
+      (newObjectWithoutReferenceToToken as any).mockReturnValue({
         classes: {
           [testClassName]: [3, 8]
         },
@@ -69,7 +69,7 @@ describe("index", () => {
 
       element.classList.add(testClassName);
 
-      release(element, 142); // actual token is irrelevant; mock takes care of it
+      releaseToken(element, 142); // actual token is irrelevant; mock takes care of it
 
       expect(element.classList.contains(testClassName)).toBe(true);
     });

packages/class-references/__tests__/tests-referenceObject.ts

@@ -1,6 +1,6 @@
 import {
   newObject,
-  newObjectWithoutReferenceToId,
+  newObjectWithoutReferenceToToken,
   newObjectWithReferenceToClass
 } from "../src/referenceObject";
 
@@ -46,7 +46,7 @@ describe("referenceObject", () => {
   describe("newObjectWithoutReferenceToId()", () => {
     it("should not change an empty object", () => {
       const obj = newObject();
-      const objRemoved = newObjectWithoutReferenceToId(obj, 0);
+      const objRemoved = newObjectWithoutReferenceToToken(obj, 0);
 
       expect(objRemoved).toEqual(obj);
     });
@@ -56,7 +56,7 @@ describe("referenceObject", () => {
 
       obj = newObjectWithReferenceToClass(obj, testClassName);
 
-      const objRemoved = newObjectWithoutReferenceToId(obj, 14);
+      const objRemoved = newObjectWithoutReferenceToToken(obj, 14);
 
       expect(objRemoved).toEqual(obj);
     });
@@ -65,7 +65,7 @@ describe("referenceObject", () => {
       let obj = newObject();
 
       obj = newObjectWithReferenceToClass(obj, testClassName);
-      obj = newObjectWithoutReferenceToId(obj, obj.lastToken);
+      obj = newObjectWithoutReferenceToToken(obj, obj.lastToken);
 
       expect(obj).toMatchSnapshot();
     });
@@ -74,8 +74,8 @@ describe("referenceObject", () => {
       let obj = newObject();
 
       obj = newObjectWithReferenceToClass(obj, testClassName);
-      obj = newObjectWithoutReferenceToId(obj, obj.lastToken);
-      obj = newObjectWithoutReferenceToId(obj, obj.lastToken); // Call again to prune empties
+      obj = newObjectWithoutReferenceToToken(obj, obj.lastToken);
+      obj = newObjectWithoutReferenceToToken(obj, obj.lastToken); // Call again to prune empties
 
       expect(obj).toMatchSnapshot();
     });
@@ -96,7 +96,7 @@ describe("referenceObject", () => {
       let objRemoved = { ...obj };
 
       for (const token of removableTokens) {
-        objRemoved = newObjectWithoutReferenceToId(objRemoved, token);
+        objRemoved = newObjectWithoutReferenceToToken(objRemoved, token);
       }
 
       expect(obj.classes[extraTestClassName]).toEqual(

packages/class-references/src/index.ts

@@ -1,6 +1,6 @@
 import { getClassReferences, setClassReferences } from "./element";
 import {
-  newObjectWithoutReferenceToId,
+  newObjectWithoutReferenceToToken,
   newObjectWithReferenceToClass
 } from "./referenceObject";
 
@@ -11,7 +11,7 @@ import {
  * @param el the element to add a class to
  * @param className the class to add
  */
-export const claimForClass = (el: HTMLElement, className: string) => {
+export const requestTokenForClass = (el: HTMLElement, className: string) => {
   const newReferences = newObjectWithReferenceToClass(
     getClassReferences(el),
     className
@@ -24,12 +24,14 @@ export const claimForClass = (el: HTMLElement, className: string) => {
 };
 
 /**
+ * Release a previously claimed token. Removes the associated class name if all
+ * the tokens have been released.
  *
  * @param el the element to release a reference on
  * @param token the token to release
  */
-export const release = (el: HTMLElement, token: number) => {
-  const newReferences = newObjectWithoutReferenceToId(
+export const releaseToken = (el: HTMLElement, token: number) => {
+  const newReferences = newObjectWithoutReferenceToToken(
     getClassReferences(el),
     token
   );

packages/class-references/src/referenceObject.ts

@@ -21,15 +21,15 @@ export const newObject = (): IReferenceObject => ({
 });
 
 /**
- * Create a new reference object by removing the id from the provided reference
- * object.
+ * Create a new reference object by removing the token from the provided
+ * reference object.
  *
  * @param obj a previous reference object
- * @param id the reference id that needs removing
+ * @param token the reference id that needs removing
  */
-export const newObjectWithoutReferenceToId = (
+export const newObjectWithoutReferenceToToken = (
   obj: IReferenceObject,
-  id: number
+  token: number
 ): IReferenceObject => ({
   classes: {
     ...(Object.entries(obj.classes) as ClassTokenListEntry[])
@@ -39,7 +39,7 @@ export const newObjectWithoutReferenceToId = (
       .map(
         ([key, values]): ClassTokenListEntry => [
           key,
-          values.filter(v => v !== id)
+          values.filter(v => v !== token)
         ]
       )
       // Convert back to object from entries

packages/react-class-references/__tests__/tests-ClassReference.tsx

@@ -1,4 +1,4 @@
-import { claimForClass, release } from "class-references";
+import { releaseToken, requestTokenForClass } from "class-references";
 import * as React from "react";
 import * as TestRenderer from "react-test-renderer";
 import ClassReference from "../src/ClassReference";
@@ -14,7 +14,7 @@ describe("<ClassReference />", () => {
     element = document.createElement("div");
     jest.resetAllMocks();
 
-    (claimForClass as any).mockReturnValue(fakeToken);
+    (requestTokenForClass as any).mockReturnValue(fakeToken);
   });
 
   it("should match default snapshot", () => {
@@ -34,7 +34,7 @@ describe("<ClassReference />", () => {
       </ClassReference>
     );
 
-    expect(claimForClass).toHaveBeenCalledWith(element, testClassName);
+    expect(requestTokenForClass).toHaveBeenCalledWith(element, testClassName);
   });
 
   it("should release on unmount", () => {
@@ -46,7 +46,7 @@ describe("<ClassReference />", () => {
 
     renderer.unmount();
 
-    expect(release).toHaveBeenCalledWith(element, fakeToken);
+    expect(releaseToken).toHaveBeenCalledWith(element, fakeToken);
   });
 
   it("should release and claim on element swap", () => {
@@ -62,8 +62,11 @@ describe("<ClassReference />", () => {
 
     renderer.update(<Test testElement={extraElement} />);
 
-    expect(release).toHaveBeenCalledWith(element, fakeToken);
-    expect(claimForClass).toHaveBeenCalledWith(extraElement, testClassName);
+    expect(releaseToken).toHaveBeenCalledWith(element, fakeToken);
+    expect(requestTokenForClass).toHaveBeenCalledWith(
+      extraElement,
+      testClassName
+    );
   });
 
   it("should release and claim on class swap", () => {
@@ -81,7 +84,7 @@ describe("<ClassReference />", () => {
 
     renderer.update(<Test classNameToAdd={extraClassName} />);
 
-    expect(release).toHaveBeenCalledWith(element, fakeToken);
-    expect(claimForClass).toHaveBeenCalledWith(element, extraClassName);
+    expect(releaseToken).toHaveBeenCalledWith(element, fakeToken);
+    expect(requestTokenForClass).toHaveBeenCalledWith(element, extraClassName);
   });
 });

packages/react-class-references/src/ClassReference.tsx

@@ -1,4 +1,4 @@
-import { claimForClass, release } from "class-references";
+import { releaseToken, requestTokenForClass } from "class-references";
 import * as React from "react";
 
 interface IProps {
@@ -14,7 +14,7 @@ interface IState {
 export default class ClassReference extends React.Component<IProps, IState> {
   public componentDidMount() {
     this.setState({
-      token: claimForClass(this.props.element, this.props.classNameToAdd)
+      token: requestTokenForClass(this.props.element, this.props.classNameToAdd)
     });
   }
 
@@ -26,16 +26,16 @@ export default class ClassReference extends React.Component<IProps, IState> {
       prevProps.element !== element ||
       prevProps.classNameToAdd !== classNameToAdd
     ) {
-      release(prevProps.element, token);
+      releaseToken(prevProps.element, token);
 
       this.setState({
-        token: claimForClass(element, classNameToAdd)
+        token: requestTokenForClass(element, classNameToAdd)
       });
     }
   }
 
   public componentWillUnmount() {
-    release(this.props.element, this.state.token);
+    releaseToken(this.props.element, this.state.token);
   }
 
   public render() {