Add typescript type definition

index.d.ts

@@ -0,0 +1,67 @@
+type DirectLyEnabled = boolean
+type EnabledEnvironments = { [k: string]: boolean }
+export type Flag = {
+  enabled: DirectLyEnabled | EnabledEnvironments
+  description: string
+  name?: string
+}
+
+type CurrentEnvironment = Readonly<{ current: string }>
+type AvailableEnvironments = string[]
+type Environments = Readonly<
+  { available: AvailableEnvironments } & CurrentEnvironment
+>
+
+type FlagWithEnvironment = Readonly<{
+  environment_flag: string
+}>
+
+export interface Config {
+  flags: { [key: string]: Flag }
+  environments?: Environments
+  sources?: Source[]
+}
+
+type SourceFn = (flag: Flag) => boolean
+type SourceObject = Readonly<{ isEnabled: SourceFn }>
+type Source = SourceFn | SourceObject
+
+type State = Flag[]
+type ChangedFlag<TFlagName> = { flag: TFlagName; originalValue: boolean }
+
+interface TestBox<TFlagName> {
+  enable: (flag: TFlagName) => void
+  disable: (flag: TFlagName) => void
+  reset: () => void
+}
+
+type SyncTogglingClosure<TFlagName> = <TResult>(
+  name: TFlagName,
+  closure: () => TResult
+) => TResult
+type AsyncTogglingClosure<TFlagName> = <TResult>(
+  name: TFlagName,
+  closure: () => Promise<TResult>
+) => Promise<TResult>
+
+export interface FeatureFlags<
+  TConfig extends Config,
+  TFlagName extends keyof TConfig['flags'] & string
+> {
+  isEnabled: (key: TFlagName) => boolean
+  summary: () => string
+  state: () => State
+  enabling: SyncTogglingClosure<TFlagName>
+  disabling: SyncTogglingClosure<TFlagName>
+  enablingAsync: AsyncTogglingClosure<TFlagName>
+  disablingAsync: AsyncTogglingClosure<TFlagName>
+  testBox: () => TestBox<TFlagName>
+}
+export declare function wrap<
+  TConfig extends Config,
+  TFlagName extends keyof TConfig['flags'] & string
+>(config: TConfig): FeatureFlags<TConfig, TFlagName>
+
+export declare namespace sources {
+  export function processEnvSource(flag: any): boolean
+}

index.js

@@ -8,7 +8,7 @@ const errors = {
   unknown_env_enabled: (flagName, envInFlag, configuredEnvs) =>
     `The feature flag ${flagName} is configured for ${envInFlag} that is not listed in environments.available: ${configuredEnvs}. Please check if this is an error.`,
   missing_environment: () =>
-    'You need to configure which environments are available to your application under config.environments.available as an array of strings. This allows us to check your config for consistency'
+    'You need to configure which environments are available to your application under config.environments.available as an array of strings. This allows us to check your config for consistency',
 }
 
 const checkConsistency = (config) => {
@@ -94,8 +94,8 @@ module.exports = {
     }
 
     return {
-      isEnabled: function(flagName) {
-        flag = flags[flagName]
+      isEnabled: function (flagName) {
+        const flag = flags[flagName]
         if (flag) {
           flag.name = flagName
           return (
@@ -108,41 +108,41 @@ module.exports = {
         }
       },
 
-      state: function() {
+      state: function () {
         return Object.keys(flags).map((flagName) => {
           return {
             name: flagName,
             enabled: this.isEnabled(flagName),
-            description: flags[flagName].description
+            description: flags[flagName].description,
           }
         })
       },
 
-      enabling: function(flagName, closure) {
+      enabling: function (flagName, closure) {
         return toggle(this, flagName, { to: true, around: closure })
       },
 
-      disabling: function(flagName, closure) {
+      disabling: function (flagName, closure) {
         return toggle(this, flagName, { to: false, around: closure })
       },
 
-      enablingAsync: async function(flagName, closure) {
+      enablingAsync: async function (flagName, closure) {
         return toggleAsync(this, flagName, { to: true, around: closure })
       },
 
-      disablingAsync: async function(flagName, closure) {
+      disablingAsync: async function (flagName, closure) {
         return toggleAsync(this, flagName, { to: false, around: closure })
       },
 
-      testBox: function() {
+      testBox: function () {
         const features = this
         let changedFlags = []
 
         const set = (flagName, { to: value }) => {
           const isEnabled = features.isEnabled(flagName)
           changedFlags = changedFlags.concat({
             flag: flagName,
-            originalValue: isEnabled
+            originalValue: isEnabled,
           })
           flags[flagName].enabled = value
         }
@@ -158,15 +158,15 @@ module.exports = {
             )
 
             changedFlags = []
-          }
+          },
         }
-      }
+      },
     }
   },
   sources: {
     processEnvSource: (flag) => {
       const value = process.env[flag.environment_flag]
       return value === '1' || value === 'true'
-    }
-  }
+    },
+  },
 }