@salesforcedevs/docs-components 1.3.149-canary.1 → 1.3.150-alpha

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforcedevs/docs-components",
-    "version": "1.3.149-canary.1",
+    "version": "1.3.150-alpha",
     "description": "Docs Lightning web components for DSC",
     "license": "MIT",
     "main": "index.js",
@@ -16,7 +16,7 @@
         "kagekiri": "^1.4.1",
         "lodash.orderby": "^4.6.0",
         "lodash.uniqby": "^4.7.0",
-        "query-string": "^7.1.1",
+        "query-string": "^7.1.3",
         "sentence-case": "^3.0.4"
     },
     "devDependencies": {

package/src/modules/doc/amfReference/amfReference.ts

@@ -1242,14 +1242,18 @@ export default class AmfReference extends LightningElement {
         }
         if (!isRedirecting) {
             const currentReferenceUrl = window.location.href;
+            console.log("currentReferenceUrl", currentReferenceUrl);
             const referenceMeta =
                 this.getMarkdownReferenceMeta(currentReferenceUrl);
+            console.log("referenceMeta", referenceMeta);
             const selectedItemRefId =
                 this.getReferenceIdFromUrl(currentReferenceUrl);
+            console.log("selectedItemRefId", selectedItemRefId);
             const referenceDetails = this.getRefDetailsForGivenTopicMeta(
                 selectedItemRefId,
                 referenceMeta
             );
+            console.log("referenceDtails", referenceDetails);
             if (referenceDetails) {
                 this.updateNavTitleMetaTag(referenceDetails.topicTitle);
             }

package/src/modules/doc/xmlContent/xmlContent.ts

@@ -13,7 +13,7 @@ import {
     TocMap
 } from "./types";
 import { SearchSyncer } from "docUtils/SearchSyncer";
-import { LightningElementWithState } from "dxBaseElements/lightningElementWithState";
+import { LightningElementWithState } from "docBaseElements/lightningElementWithState";
 import { oldVersionDocInfo } from "docUtils/utils";
 import { Breadcrumb, DocPhaseInfo, Language } from "typings/custom";
 import { track as trackGTM } from "dxUtils/analytics";

package/src/modules/docBaseElements/lightningElementWithState/lightningElementWithState.ts

@@ -0,0 +1,93 @@
+import { LightningElement, track } from "lwc";
+
+/**
+ * This is a helper class for when you want your LWC component to have state
+ * that is automatically tracked _along with_ its previous state, in a React-
+ * like fashion, so that you can compare current state with previous state
+ * after a render (like React's `commponentDidUpdate`). One benefit of doing
+ * things this way is that you can put all of your reactions to state changes
+ * in one place, in `renderedCallback`, rather than having them in various
+ * places throughout the component.
+ *
+ * The API consists in `this.prevState`, `this.state`, and `this.setState`.
+ *
+ * Usage:
+ *
+ * ```
+ * type MyState = {
+ *     isFetchingContent: boolean;
+ * };
+ *
+ * class MyFetchingComponent extends LightningElementWithState<MyState> {
+ *     constructor() {
+ *         // `this.state` can only be initialized once
+ *         this.state = {
+ *             isFetchingContent: false
+ *         };
+ *     }
+ *
+ *     // Queued for execution whenever a `setState` call completes
+ *     renderedCallback() {
+ *         if (this.prevState.isFetchingContent && !this.state.isFetchingContent) {
+ *             // Do something knowing that we just finished fetching.
+ *             notifyFetchSuccessful();
+ *         }
+ *     }
+ *
+ *     fetchSomething() {
+ *         this.setState({
+ *             isFetchingContent: true
+ *         });
+ *
+ *         fetch(whatever).then(() => {
+ *             this.setState({
+ *                 isFetching: false
+ *             }
+ *         });
+ *     }
+ * }
+ * ```
+ */
+export abstract class LightningElementWithState<
+    T extends { [key: string]: unknown }
+> extends LightningElement {
+    private _prevState = {} as T;
+    @track private _state = {} as T;
+
+    private _didInitializeState = false;
+
+    protected get prevState(): T {
+        return Object.freeze({
+            ...this._prevState
+        });
+    }
+
+    protected get state(): T {
+        return Object.freeze({
+            ...this._state
+        });
+    }
+
+    protected set state(initialState: T) {
+        if (!this._didInitializeState) {
+            this._state = {
+                ...initialState
+            };
+            this._didInitializeState = true;
+        } else {
+            throw new Error(
+                "To mutate state after initialization, use `this.setState`."
+            );
+        }
+    }
+
+    protected setState = (state: Partial<T>): void => {
+        this._prevState = {
+            ...this._state
+        };
+        this._state = {
+            ...this._state,
+            ...state
+        };
+    };
+}