angular-toolbox 0.11.2 → 0.11.4

package/esm2022/lib/util/http-mocking-framework-config.manager.mjs

@@ -0,0 +1,129 @@
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+import { HttpMockProductionPolicy } from "../model";
+import { HttpMockServiceError } from "../core";
+/**
+ * @private
+ */
+const POLICY_WARNING = "HTTP Mocking Framework is running in production mode";
+/**
+ * @private
+ */
+const POLICY_ERROR = new HttpMockServiceError(POLICY_WARNING + ": remove all framework references or change the 'productionPolicy' property value of the HTTP_MOCKING_FRAMEWORK_CONFIG provider.");
+/**
+ * @private
+ */
+const FLAG_ID = "http-mocking-framework-flag";
+/**
+ * The object that manages the HTTP Mocking Framework options.
+ */
+export class HttpMockingFrameworkConfigManager {
+    /**
+     * Returns the value specified by the `disableVisualFlag` of the `HttpMockingFrameworkConfig` provider,
+     * or `false` when no provider is defined.
+     */
+    get disableVisualFlag() {
+        const cfg = this._config;
+        return cfg && cfg.disableVisualFlag ? cfg.disableVisualFlag : false;
+    }
+    /**
+     * Returns the value specified by the `productionPolicy` of the `HttpMockingFrameworkConfig` provider,
+     * or `HttpMockProductionPolicy.ERROR` when no provider is defined.
+     */
+    get productionPolicy() {
+        return this._prodPolicy;
+    }
+    /**
+     * @private
+     * Creates and Initializes the manager with the specified config.
+     *
+     * @param document The reference to the `Document` object, injected by Angular.
+     * @param isDevMode Indicates wheter Angular runs in development mode (`true`), or in production mode (`false`).
+     * @param config The `HttpMockingFrameworkConfi` provider.
+     */
+    constructor(document, isDevMode, config) {
+        this._isProdMode = !isDevMode;
+        this._document = document;
+        this._config = config;
+        this._prodPolicy = config && config.productionPolicy !== undefined ? config.productionPolicy : HttpMockProductionPolicy.ERROR;
+        this.checkPolicy();
+        this.createVisualFlag(document, config);
+    }
+    /**
+     * Apply a strategy depending on the current production policy and environment.
+     * @param route An optional parameter used when the methhod is associated to a HTTP request.
+     *              Must be the representation of the intercepted route path.
+     * @param method An optional parameter used when the methhod is associated to a HTTP request.
+     *               Must be the representation of the intercepted HTTP method.
+     */
+    checkPolicy(route, method = undefined) {
+        if (!this._isProdMode)
+            return;
+        if (this._prodPolicy === HttpMockProductionPolicy.ERROR)
+            throw POLICY_ERROR;
+        if (this._prodPolicy === HttpMockProductionPolicy.SILENT)
+            return;
+        const routeMsg = route ? `: intercepted request=[path=${route}, method=${method?.toUpperCase()}]` : ".";
+        console.warn(POLICY_WARNING + routeMsg);
+    }
+    /**
+     * @private
+     */
+    destroy() {
+        const cfg = this._config;
+        const noFlag = (cfg && cfg.disableVisualFlag) === true;
+        this._config = null;
+        if (noFlag)
+            return;
+        const doc = this._document;
+        const flag = doc.getElementById(FLAG_ID);
+        if (flag) {
+            flag.onmouseover = flag.onmouseout = null;
+            doc.body.removeChild(flag);
+        }
+    }
+    /**
+     * @private
+     */
+    createVisualFlag(document, config) {
+        if (config && config.disableVisualFlag)
+            return;
+        const flag = document.createElement("div");
+        const text = document.createTextNode("HTTP Mocking Framwork");
+        const style = flag.style;
+        const body = document.body;
+        flag.setAttribute("id", FLAG_ID);
+        style.backgroundColor = "red";
+        style.color = "white";
+        style.textAlign = "center";
+        style.position = "fixed";
+        style.width = "100%";
+        style.overflow = "hidden";
+        style.height = "26px";
+        style.transition = "all 0.25s ease-in-out";
+        style.zIndex = "10000";
+        style.opacity = "1";
+        style.userSelect = "none";
+        flag.onmouseover = () => {
+            style.height = "26px";
+            style.opacity = "1";
+        };
+        flag.onmouseout = () => {
+            style.height = "6px";
+            style.opacity = "0.35";
+        };
+        flag.appendChild(text);
+        body.insertBefore(flag, body.firstChild);
+        setTimeout(() => {
+            style.height = "4px";
+            style.opacity = "0.35";
+        }, 4000);
+    }
+}
+;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http-mocking-framework-config.manager.js","sourceRoot":"","sources":["../../../../../projects/angular-toolbox/src/lib/util/http-mocking-framework-config.manager.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * @license\r\n * Copyright Pascal ECHEMANN. All Rights Reserved.\r\n *\r\n * Use of this source code is governed by an MIT-style license that can be found in\r\n * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license\r\n */\r\n\r\nimport { Destroyable, HttpMockProductionPolicy } from \"../model\";\r\nimport { HttpMockingFrameworkConfig } from \"../model/business/mock/http/config/http-mocking-framework-config\";\r\nimport { HttpMockServiceError } from \"../core\";\r\nimport { HTTPMethodRef } from \"../framework/mock/http/util/http-method-ref.enum\";\r\n\r\n/**\r\n * @private\r\n */\r\nconst POLICY_WARNING: string = \"HTTP Mocking Framework is running in production mode\";\r\n\r\n/**\r\n * @private\r\n */\r\nconst POLICY_ERROR: HttpMockServiceError = new HttpMockServiceError(POLICY_WARNING + \": remove all framework references or change the 'productionPolicy' property value of the HTTP_MOCKING_FRAMEWORK_CONFIG provider.\");\r\n\r\n/**\r\n * @private\r\n */\r\nconst FLAG_ID: string = \"http-mocking-framework-flag\";\r\n\r\n/**\r\n * The object that manages the HTTP Mocking Framework options.\r\n */\r\nexport class HttpMockingFrameworkConfigManager implements Destroyable {\r\n\r\n    /**\r\n     * @private\r\n     */\r\n    private _document!: Document;\r\n    \r\n    /**\r\n     * @private\r\n     */\r\n    private _config?: HttpMockingFrameworkConfig;\r\n    \r\n    /**\r\n     * @private\r\n     */\r\n    private readonly _isProdMode: boolean;\r\n\r\n    /**\r\n     * @private\r\n     */\r\n    private readonly _prodPolicy: HttpMockProductionPolicy;\r\n\r\n    /**\r\n     * Returns the value specified by the `disableVisualFlag` of the `HttpMockingFrameworkConfig` provider,\r\n     * or `false` when no provider is defined.\r\n     */\r\n    public get disableVisualFlag(): boolean {\r\n        const cfg: HttpMockingFrameworkConfig | undefined = this._config;\r\n        return cfg && cfg.disableVisualFlag ? cfg.disableVisualFlag : false;\r\n    }\r\n\r\n    /**\r\n     * Returns the value specified by the `productionPolicy` of the `HttpMockingFrameworkConfig` provider,\r\n     * or `HttpMockProductionPolicy.ERROR` when no provider is defined.\r\n     */\r\n    public get productionPolicy(): HttpMockProductionPolicy {\r\n        return this._prodPolicy;\r\n    }\r\n\r\n    /**\r\n     * @private\r\n     * Creates and Initializes the manager with the specified config.\r\n     * \r\n     * @param document The reference to the `Document` object, injected by Angular.\r\n     * @param isDevMode Indicates wheter Angular runs in development mode (`true`), or in production mode (`false`).\r\n     * @param config The `HttpMockingFrameworkConfi` provider.\r\n     */\r\n    constructor(document: Document, isDevMode: boolean, config?: HttpMockingFrameworkConfig) {\r\n        this._isProdMode = !isDevMode;\r\n        this._document = document;\r\n        this._config = config;\r\n        this._prodPolicy = config && config.productionPolicy !== undefined ? config.productionPolicy : HttpMockProductionPolicy.ERROR;\r\n        this.checkPolicy();\r\n        this.createVisualFlag(document, config);\r\n    }\r\n    \r\n    /**\r\n     * Apply a strategy depending on the current production policy and environment.\r\n     * @param route An optional parameter used when the methhod is associated to a HTTP request.\r\n     *              Must be the representation of the intercepted route path.\r\n     * @param method An optional parameter used when the methhod is associated to a HTTP request.\r\n     *               Must be the representation of the intercepted HTTP method.\r\n     */\r\n    public checkPolicy(route?: string, method: HTTPMethodRef | undefined = undefined): void {\r\n        if (!this._isProdMode) return;\r\n        if (this._prodPolicy === HttpMockProductionPolicy.ERROR) throw POLICY_ERROR;\r\n        if (this._prodPolicy === HttpMockProductionPolicy.SILENT) return;\r\n        const routeMsg: string = route ? `: intercepted request=[path=${route}, method=${method?.toUpperCase()}]` : \".\";\r\n        console.warn(POLICY_WARNING + routeMsg);\r\n    }\r\n\r\n    /**\r\n     * @private\r\n     */\r\n    public destroy(): void {\r\n        const cfg: HttpMockingFrameworkConfig | undefined = this._config;\r\n        const noFlag: boolean = (cfg && cfg.disableVisualFlag) === true;\r\n        this._config = null as any;\r\n        if (noFlag)  return;\r\n        const doc: Document = this._document;\r\n        const flag: HTMLElement | null = doc.getElementById(FLAG_ID);\r\n        if (flag) {\r\n            flag.onmouseover = flag.onmouseout =null;\r\n            doc.body.removeChild(flag);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @private\r\n     */\r\n    private createVisualFlag(document: Document, config?: HttpMockingFrameworkConfig): void {\r\n        if (config && config.disableVisualFlag) return;\r\n        const flag: HTMLDivElement = document.createElement(\"div\");\r\n        const text: Text = document.createTextNode(\"HTTP Mocking Framwork\");\r\n        const style: CSSStyleDeclaration = flag.style;\r\n        const body = document.body;\r\n        flag.setAttribute(\"id\", FLAG_ID);\r\n        style.backgroundColor = \"red\";\r\n        style.color = \"white\";\r\n        style.textAlign = \"center\";\r\n        style.position = \"fixed\";\r\n        style.width = \"100%\";\r\n        style.overflow = \"hidden\";\r\n        style.height = \"26px\";\r\n        style.transition = \"all 0.25s ease-in-out\";\r\n        style.zIndex = \"10000\";\r\n        style.opacity = \"1\";\r\n        style.userSelect = \"none\";\r\n        flag.onmouseover = ()=> {\r\n            style.height = \"26px\";\r\n            style.opacity = \"1\";\r\n        };\r\n        flag.onmouseout = ()=> {\r\n            style.height = \"6px\";\r\n            style.opacity = \"0.35\";\r\n        };\r\n        flag.appendChild(text);\r\n        body.insertBefore(flag, body.firstChild);\r\n        setTimeout(()=> {\r\n            style.height = \"4px\";\r\n            style.opacity = \"0.35\";\r\n        }, 4000);\r\n    }\r\n};"]}