@tehw0lf/yaft 0.0.2 → 0.0.4

package/src/test/test-feature.json

@@ -0,0 +1,20 @@
+{
+  "myClassToggle": {
+    "key": "myClassToggle",
+    "value": "false",
+    "activeAt": "",
+    "disabledAt": ""
+  },
+  "myMethodToggle": {
+    "key": "myMethodToggle",
+    "value": "true",
+    "activeAt": "",
+    "disabledAt": ""
+  },
+  "myOtherMethodToggle": {
+    "key": "myOtherMethodToggle",
+    "value": "false",
+    "activeAt": "",
+    "disabledAt": ""
+  }
+}

package/src/test/test-setup.ts

@@ -0,0 +1,2 @@
+import 'reflect-metadata';
+

package/src/test/yaft.demo.spec.ts

@@ -0,0 +1,53 @@
+import { FeatureToggle, FeatureToggleBase } from "..";
+import { LocalStorageFeatureProvider } from "../examples/LocalStorageFeatureProvider";
+
+FeatureToggleBase.featureProvider = new LocalStorageFeatureProvider(
+  "../test/test-feature.json"
+);
+
+class Demo3 {
+  constructor() {}
+
+  async five() {
+    return Promise.resolve(9);
+  }
+}
+
+@FeatureToggle("myClassToggle", Demo3)
+class Demo2 {
+  constructor() {}
+
+  async five() {
+    return Promise.resolve(5);
+  }
+}
+
+function myFallback() {
+  console.log("hiyaa");
+}
+
+export class Demo {
+  demo: Demo2;
+  constructor() {
+    this.demo = new Demo2();
+  }
+
+  @FeatureToggle("myMethodToggle")
+  method() {
+    console.log("Hello world!");
+    this.demo.five().then((val) => console.log(val));
+  }
+
+  @FeatureToggle("myOtherMethodToggle", myFallback)
+  othermethod() {
+    console.log("Hello other world!");
+  }
+}
+
+describe("YaFT Demo", () => {
+  it("should create test", () => {
+    const test = new Demo();
+    test.method();
+    test.othermethod();
+  });
+});

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "ES2022",
+    "experimentalDecorators": true,
+    "declaration": true,
+    "outDir": "./dist"
+  },
+  "include": ["**/**/*.ts"]
+}

package/tsconfig.spec.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "module": "esnext",
+    "types": ["jest", "node"]
+  },
+  "files": ["src/test/test-setup.ts"],
+  "include": ["**/*.spec.ts", "**/*.d.ts", "jest.config.ts"]
+}

package/FeatureToggle.d.ts

@@ -1,19 +0,0 @@
-import "reflect-metadata";
-export type Feature = {
-    key: string;
-    value: string;
-    activeAt: string;
-    disabledAt: string;
-};
-export interface FeatureProvider<T> {
-    apiUrl?: string;
-    baseUUID?: string;
-    data: Record<string, T>;
-    getCollectionHash?(configPathOrUrl: string): void;
-    getConfig(configPathOrUrl: string): void;
-    isEnabled(key: string): boolean;
-}
-export declare function FeatureToggle(key: string, fallback?: any): (target: any, propertyKey?: string, descriptor?: PropertyDescriptor) => any;
-export declare abstract class FeatureToggleBase {
-    static featureProvider: FeatureProvider<any>;
-}

package/FeatureToggle.js

@@ -1,60 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FeatureToggleBase = exports.FeatureToggle = void 0;
-require("reflect-metadata");
-class EmptyClass {
-    constructor() { }
-}
-function FeatureToggle(key, fallback) {
-    if (!FeatureToggleBase.featureProvider) {
-        throw new Error("FeatureToggleProvider not set");
-    }
-    const isEnabled = FeatureToggleBase.featureProvider.isEnabled(key);
-    return (target, propertyKey, descriptor) => {
-        if (propertyKey && descriptor) {
-            // Method
-            const originalMethod = descriptor.value;
-            descriptor.value = function (...args) {
-                if (isEnabled) {
-                    return originalMethod.apply(this, args);
-                }
-                else {
-                    return fallback !== undefined
-                        ? fallback.apply(this, args)
-                        : (() => { }).apply(this, args);
-                }
-            };
-            return descriptor;
-        }
-        else {
-            // Class
-            const originalConstructor = target;
-            let newConstructor;
-            if (isEnabled) {
-                newConstructor = originalConstructor;
-            }
-            else {
-                newConstructor = fallback !== undefined ? fallback : EmptyClass;
-                if (fallback)
-                    newConstructor.__proto__ = fallback.__proto__;
-                if (newConstructor === EmptyClass) {
-                    Object.getOwnPropertyNames(originalConstructor.prototype).forEach((name) => {
-                        if (name === "constructor")
-                            return;
-                        if (typeof originalConstructor.prototype[name] === "function")
-                            newConstructor.prototype[name] = () => { };
-                        if (originalConstructor.prototype[name][Symbol.toStringTag] ===
-                            "AsyncFunction")
-                            newConstructor.prototype[name] = async () => { };
-                    });
-                }
-            }
-            return newConstructor;
-        }
-    };
-}
-exports.FeatureToggle = FeatureToggle;
-class FeatureToggleBase {
-    static featureProvider;
-}
-exports.FeatureToggleBase = FeatureToggleBase;

package/index.d.ts

@@ -1 +0,0 @@
-export { Feature, FeatureToggle, FeatureToggleBase, FeatureProvider, } from "./FeatureToggle";

package/index.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FeatureToggleBase = exports.FeatureToggle = void 0;
-var FeatureToggle_1 = require("./FeatureToggle");
-Object.defineProperty(exports, "FeatureToggle", { enumerable: true, get: function () { return FeatureToggle_1.FeatureToggle; } });
-Object.defineProperty(exports, "FeatureToggleBase", { enumerable: true, get: function () { return FeatureToggle_1.FeatureToggleBase; } });