@flagsmith/flagsmith 11.0.0-internal.1

package/src/index.d.ts

@@ -0,0 +1,8 @@
+import { IFlagsmith } from './types';
+declare const flagsmith: IFlagsmith;
+export default flagsmith;
+export * from './types';
+export declare const createFlagsmithInstance: <
+    F extends string = string,
+    T extends string = string,
+    >() => IFlagsmith<F, T>;

package/src/index.ts

@@ -0,0 +1,22 @@
+import { IFlagsmith } from './types';
+
+// @ts-ignore
+globalThis.FlagsmithEventSource = typeof EventSource!== "undefined"? EventSource: null;
+
+import fetch from "unfetch"
+import AsyncStorage from "./utils/async-storage";
+import core, { LikeFetch } from './flagsmith-core';
+import _EventSource from 'reconnecting-eventsource'
+// @ts-expect-error
+const _fetch = fetch as LikeFetch
+const flagsmith = core({AsyncStorage, fetch:_fetch, eventSource:_EventSource});
+if (typeof window !== "undefined") {
+    // @ts-expect-error, some people wish to use flagsmith globally
+    window.flagsmith = flagsmith;
+}
+
+export default flagsmith;
+export const createFlagsmithInstance = ():IFlagsmith=>{
+    return core({ AsyncStorage, fetch:_fetch, eventSource:_EventSource})
+}
+export { FlagSource } from './flagsmith-core';

package/src/isomorphic.d.ts

@@ -0,0 +1,5 @@
+import { IFlagsmith } from "./types";
+declare const flagsmith: IFlagsmith;
+export default flagsmith;
+export declare const createFlagsmithInstance: () => IFlagsmith;
+export { FlagSource } from './flagsmith-core';

package/src/isomorphic.ts

@@ -0,0 +1,27 @@
+import AsyncStorage from "./utils/async-storage";
+import {IFlagsmith} from "./types";
+import core from './flagsmith-core'
+
+// @ts-ignore
+globalThis.FlagsmithEventSource = typeof EventSource !== 'undefined' ? EventSource : null;
+import eventSource from 'reconnecting-eventsource'
+
+
+const flagsmith: IFlagsmith = core({
+    AsyncStorage,
+    eventSource: typeof window !=='undefined'?eventSource : null
+});
+
+if (typeof window !== "undefined") {
+    // @ts-ignore
+    window.flagsmith = flagsmith;
+}
+export default flagsmith;
+
+export const createFlagsmithInstance = (): IFlagsmith => {
+    return core({
+        AsyncStorage,
+        eventSource: typeof window !=='undefined'?eventSource : null
+    })
+}
+export { FlagSource } from './flagsmith-core';

package/src/next-middleware.d.ts

@@ -0,0 +1,5 @@
+import { IFlagsmith } from './types';
+declare const flagsmith: IFlagsmith<string, string>;
+export default flagsmith;
+export declare const createFlagsmithInstance: () => IFlagsmith;
+export { FlagSource } from './flagsmith-core';

package/src/next-middleware.ts

@@ -0,0 +1,8 @@
+import { IFlagsmith } from './types';
+import core from './flagsmith-core'
+const flagsmith = core({});
+export default flagsmith;
+export const createFlagsmithInstance = ():IFlagsmith=>{
+    return core({})
+}
+export { FlagSource } from './flagsmith-core';

package/src/react.d.ts

@@ -0,0 +1,32 @@
+import React, { FC } from 'react';
+import { IFlagsmith, IFlagsmithTrait, IFlagsmithFeature, IState, LoadingState } from './types';
+export * from './types';
+export declare const FlagsmithContext: React.Context<IFlagsmith>;
+export declare type FlagsmithContextType<F extends string = string, T extends string = string> = {
+    flagsmith: IFlagsmith<F, T>;
+    options?: Parameters<IFlagsmith<F, T>['init']>[0];
+    serverState?: IState;
+    children: React.ReactNode;
+};
+type UseFlagsReturn<
+    F extends string | Record<string, any>,
+    T extends string
+> = [F] extends [string]
+    ? {
+    [K in F]: IFlagsmithFeature;
+} & {
+    [K in T]: IFlagsmithTrait;
+}
+    : {
+    [K in keyof F]: IFlagsmithFeature<F[K]>;
+} & {
+    [K in T]: IFlagsmithTrait;
+};
+export declare const FlagsmithProvider: FC<FlagsmithContextType>;
+export declare function useFlags<
+    F extends string | Record<string, any>,
+    T extends string = string
+>(_flags: readonly (F | keyof F)[], _traits?: readonly T[]): UseFlagsReturn<F, T>;
+export declare const useFlagsmith: <F extends string | Record<string, any>,
+    T extends string = string>() => IFlagsmith<F, T>;
+export declare const useFlagsmithLoading: () => LoadingState | undefined;

package/src/react.tsx

@@ -0,0 +1,200 @@
+import React, { createContext, FC, useCallback, useContext, useEffect, useMemo, useRef, useState } from 'react'
+import Emitter from './utils/emitter'
+const events = new Emitter()
+
+import { IFlagsmith, IFlagsmithTrait, IFlagsmithFeature, IState } from './types'
+
+export const FlagsmithContext = createContext<IFlagsmith<string, string> | null>(null)
+export type FlagsmithContextType = {
+    flagsmith: IFlagsmith // The flagsmith instance
+    options?: Parameters<IFlagsmith['init']>[0] // Initialisation options, if you do not provide this you will have to call init manually
+    serverState?: IState
+    children: React.ReactNode
+}
+
+export const FlagsmithProvider: FC<FlagsmithContextType> = ({ flagsmith, options, serverState, children }) => {
+    const firstRenderRef = useRef(true)
+    if (flagsmith && !flagsmith?._trigger) {
+        flagsmith._trigger = () => {
+            // @ts-expect-error using internal function, consumers would never call this
+            flagsmith?.log('React - trigger event received')
+            events.emit('event')
+        }
+    }
+
+    if (flagsmith && !flagsmith?._triggerLoadingState) {
+        flagsmith._triggerLoadingState = () => {
+            events.emit('loading_event')
+        }
+    }
+
+    if (serverState && !flagsmith.initialised) {
+        flagsmith.setState(serverState)
+    }
+
+    if (firstRenderRef.current) {
+        firstRenderRef.current = false
+        if (options) {
+            flagsmith
+                .init({
+                    ...options,
+                    state: options.state || serverState,
+                    onChange: (...args) => {
+                        if (options.onChange) {
+                            options.onChange(...args)
+                        }
+                    },
+                })
+                .catch((error) => {
+                    // @ts-expect-error using internal function, consumers would never call this
+                    flagsmith?.log('React - Failed to initialize flagsmith', error)
+                    events.emit('event')
+                })
+        }
+    }
+    return <FlagsmithContext.Provider value={flagsmith}>{children}</FlagsmithContext.Provider>
+}
+
+const useConstant = function <T>(value: T): T {
+    const ref = useRef(value)
+    if (!ref.current) {
+        ref.current = value
+    }
+    return ref.current
+}
+
+const flagsAsArray = (_flags: any): string[] => {
+    if (typeof _flags === 'string') {
+        return [_flags]
+    } else if (typeof _flags === 'object') {
+        // eslint-disable-next-line no-prototype-builtins
+        if (_flags.hasOwnProperty('length')) {
+            return _flags
+        }
+    }
+    throw new Error('Flagsmith: please supply an array of strings or a single string of flag keys to useFlags')
+}
+
+const getRenderKey = (flagsmith: IFlagsmith, flags: string[], traits: string[] = []) => {
+    return flags
+        .map((k) => {
+            return `${flagsmith.getValue(k)}${flagsmith.hasFeature(k)}`
+        })
+        .concat(traits.map((t) => `${flagsmith.getTrait(t)}`))
+        .join(',')
+}
+
+export function useFlagsmithLoading() {
+    const flagsmith = useContext(FlagsmithContext)
+    const [loadingState, setLoadingState] = useState(flagsmith?.loadingState)
+    const [subscribed, setSubscribed] = useState(false)
+    const refSubscribed = useRef(subscribed)
+
+    const eventListener = useCallback(() => {
+        setLoadingState(flagsmith?.loadingState)
+    }, [flagsmith])
+    if (!refSubscribed.current) {
+        events.on('loading_event', eventListener)
+        refSubscribed.current = true
+    }
+
+    useEffect(() => {
+        if (!subscribed && flagsmith?.initialised) {
+            events.on('loading_event', eventListener)
+            setSubscribed(true)
+        }
+        return () => {
+            if (subscribed) {
+                events.off('loading_event', eventListener)
+            }
+        }
+    }, [flagsmith, subscribed, eventListener])
+
+    return loadingState
+}
+
+type UseFlagsReturn<F extends string | Record<string, any>, T extends string> = F extends string
+    ? {
+          [K in F]: IFlagsmithFeature
+      } & {
+          [K in T]: IFlagsmithTrait
+      }
+    : {
+          [K in keyof F]: IFlagsmithFeature<F[K]>
+      } & {
+          [K in T]: IFlagsmithTrait
+      }
+
+/**
+ * Example usage:
+ *
+ * // A) Using string flags:
+ * useFlags<"featureOne"|"featureTwo">(["featureOne", "featureTwo"]);
+ *
+ * // B) Using an object for F - this can be generated by our CLI: https://github.com/Flagsmith/flagsmith-cli :
+ * interface MyFeatureInterface {
+ *   featureOne: string;
+ *   featureTwo: number;
+ * }
+ * useFlags<MyFeatureInterface>(["featureOne", "featureTwo"]);
+ */
+export function useFlags<F extends string | Record<string, any>, T extends string = string>(
+    _flags: readonly (F | keyof F)[],
+    _traits: readonly T[] = []
+) {
+    const firstRender = useRef(true)
+    const flags = useConstant<string[]>(flagsAsArray(_flags))
+    const traits = useConstant<string[]>(flagsAsArray(_traits))
+    const flagsmith = useContext(FlagsmithContext)
+    const [renderRef, setRenderRef] = useState(getRenderKey(flagsmith as IFlagsmith, flags, traits))
+    const eventListener = useCallback(() => {
+        const newRenderKey = getRenderKey(flagsmith as IFlagsmith, flags, traits)
+        if (newRenderKey !== renderRef) {
+            // @ts-expect-error using internal function, consumers would never call this
+            flagsmith?.log('React - useFlags flags and traits have changed')
+            setRenderRef(newRenderKey)
+        }
+    }, [renderRef])
+    const emitterRef = useRef(events.once('event', eventListener))
+
+    if (firstRender.current) {
+        firstRender.current = false
+        // @ts-expect-error using internal function, consumers would never call this
+        flagsmith?.log('React - Initialising event listeners')
+    }
+
+    useEffect(() => {
+        return () => {
+            emitterRef.current?.()
+        }
+    }, [])
+
+    const res = useMemo(() => {
+        const res: any = {}
+        flags
+            .map((k) => {
+                res[k] = {
+                    enabled: flagsmith!.hasFeature(k),
+                    value: flagsmith!.getValue(k),
+                }
+            })
+            .concat(
+                traits?.map((v) => {
+                    res[v] = flagsmith!.getTrait(v)
+                })
+            )
+        return res
+    }, [renderRef])
+
+    return res as UseFlagsReturn<F, T>
+}
+
+export function useFlagsmith<F extends string | Record<string, any>, T extends string = string>() {
+    const context = useContext(FlagsmithContext)
+
+    if (!context) {
+        throw new Error('useFlagsmith must be used with in a FlagsmithProvider')
+    }
+
+    return context as unknown as IFlagsmith<F, T>
+}

package/src/readme.md

@@ -0,0 +1 @@
+This folder contains auto-generated sourcemaps.

package/src/types.d.ts

@@ -0,0 +1,338 @@
+import { EvaluationContext, IdentityEvaluationContext, TraitEvaluationContext } from "./evaluation-context";
+import { FlagSource } from "./flagsmith-core";
+
+type IFlagsmithValue<T = string | number | boolean | null> = T
+
+export type DynatraceObject = {
+    "javaLongOrObject": Record<string, number>,
+    "date": Record<string, Date>,
+    "shortString": Record<string, string>,
+    "javaDouble": Record<string, number>,
+}
+
+export interface IFlagsmithFeature<Value = IFlagsmithValue> {
+    id?: number;
+    enabled: boolean;
+    value: Value;
+}
+
+export declare type IFlagsmithTrait = IFlagsmithValue | TraitEvaluationContext;
+export declare type IFlags<F extends string = string> = Record<F, IFlagsmithFeature>;
+export declare type ITraits<T extends string = string> = Record<T, IFlagsmithTrait>;
+export declare type Traits<T extends string = string> = Record<T, TraitEvaluationContext | null>;
+
+export interface ClientIdentityEvaluationContext extends Omit<IdentityEvaluationContext, "traits"> {
+    traits?:     null | ITraits;
+}
+export interface ClientEvaluationContext extends Omit<EvaluationContext, "identity"> {
+    identity?: null | ClientIdentityEvaluationContext;
+}
+
+export declare type GetValueOptions<T = Array<any> | object> = {
+    skipAnalytics?: boolean
+    json?: boolean
+    fallback?: T
+}
+
+export declare type HasFeatureOptions = {
+    skipAnalytics?: boolean
+    fallback?: boolean
+} | boolean
+
+
+export declare type IIdentity<T = string> = T;
+
+export interface IRetrieveInfo {
+    isFromServer: boolean;
+    flagsChanged: string[] | null;
+    traitsChanged: string[] | null;
+}
+
+export interface IState<F extends string = string> {
+    api: string;
+    flags?: IFlags<FKey<F>>;
+    evaluationContext?: EvaluationContext;
+    evaluationEvent?: Record<string, Record<string, number>> | null;
+    ts?: number;
+    identity?: string;
+}
+
+declare type ICacheOptions = {
+    ttl?: number;
+    skipAPI?: boolean;
+    storageKey?: string;
+    loadStale?: boolean;
+};
+
+export declare type IDatadogRum = {
+    trackTraits: boolean
+    client: {
+        setUser: (newUser: {
+            [x: string]: unknown
+        }) => void;
+        getUser: () => {
+            [x: string]: unknown
+        };
+        [extraProps: string]: any
+    }
+}
+
+
+export type ISentryClient = {
+    getIntegrationByName(name:"FeatureFlags"): {
+        addFeatureFlag(flag: string, enabled: boolean): void;
+    } | undefined;
+} | undefined;
+
+
+export { FlagSource };
+
+export declare type LoadingState = {
+    error: Error | null, // Current error, resets on next attempt to fetch flags
+    isFetching: boolean, // Whether there is a current request to fetch server flags
+    isLoading: boolean,  // Whether any flag data exists
+    source: FlagSource // Indicates freshness of flags
+}
+
+export type OnChange<F extends string = string> = (previousFlags: IFlags<FKey<F>> | null, params: IRetrieveInfo, loadingState:LoadingState) => void
+
+export type ApplicationMetadata = {
+    name: string;
+    version?: string;
+}
+
+export interface IInitConfig<F extends string | Record<string, any> = string, T extends string = string> {
+    AsyncStorage?: any;
+    api?: string;
+    evaluationContext?: ClientEvaluationContext;
+    cacheFlags?: boolean;
+    cacheOptions?: ICacheOptions;
+    datadogRum?: IDatadogRum;
+    sentryClient?: ISentryClient;
+    defaultFlags?: IFlags<FKey<F>>;
+    fetch?: any;
+    realtime?: boolean;
+    eventSourceUrl?: string;
+    enableAnalytics?: boolean;
+    enableDynatrace?: boolean;
+    enableLogs?: boolean;
+    angularHttpClient?: any;
+    environmentID?: string;
+    headers?: object;
+    identity?: IIdentity;
+    traits?: ITraits<T>;
+    onChange?: OnChange<FKey<F>>;
+    onError?: (err: Error) => void;
+    preventFetch?: boolean;
+    state?: IState;
+    _trigger?: () => void;
+    _triggerLoadingState?: () => void;
+    /**
+     * Customer application metadata
+     */
+    applicationMetadata?: ApplicationMetadata;
+    /**
+     * Configuration for the evaluation analytics pipeline. When provided,
+     * individual flag evaluation events are buffered and sent to the pipeline endpoint.
+     */
+    evaluationAnalyticsConfig?: {
+        /** URL of the pipeline server (e.g. 'https://analytics.flagsmith.com/'). */
+        analyticsServerUrl: string;
+        /** Maximum events to buffer in memory before dropping oldest. Default 1000. */
+        maxBuffer?: number;
+        /** Flush interval in milliseconds. Set to 0 to flush immediately after each evaluation. Default 10000 (10s). */
+        flushInterval?: number;
+    };
+}
+
+export interface IPipelineEvent {
+    event_id: string; // flag_name or event_name
+    event_type: 'flag_evaluation' | 'custom_event';
+    evaluated_at: number;
+    identity_identifier: string | null;
+    enabled?: boolean | null;
+    value: IFlagsmithValue;
+    traits?: { [key: string]: null | TraitEvaluationContext } | null;
+    metadata?: Record<string, any> | null;
+}
+
+export interface IPipelineEventBatch {
+    events: IPipelineEvent[];
+    environment_key: string;
+}
+
+export interface IFlagsmithResponse {
+    identifier?: string,
+    traits?: {
+        trait_key: string;
+        trait_value: IFlagsmithValue;
+        transient?: boolean;
+    }[];
+    flags?: {
+        enabled: boolean;
+        feature_state_value: IFlagsmithValue;
+        feature: {
+            id: number;
+            name: string;
+        };
+    }[];
+}
+type FKey<F> = F extends string ? F : keyof F;
+type FValue<F, K extends FKey<F>> = F extends Record<string, any>
+    ? F[K] | null
+    : IFlagsmithValue;
+
+/**
+ * Example usage:
+ *
+ * // A) Using string flags:
+ * import flagsmith from 'flagsmith' as IFlagsmith<"featureOne"|"featureTwo">;
+ *
+ * // B) Using an object for F - this can be generated by our CLI: https://github.com/Flagsmith/flagsmith-cli :
+ * interface MyFeatureInterface {
+ *   featureOne: string;
+ *   featureTwo: number;
+ * }
+ * import flagsmith from 'flagsmith' as IFlagsmith<MyFeatureInterface>;
+ */
+export interface IFlagsmith<
+F extends string | Record<string, any> = string,
+T extends string = string
+>
+{
+    /**
+     * Initialise the sdk against a particular environment
+     */
+    init: (config: IInitConfig<FKey<F>, T>) => Promise<void>;
+    /**
+     * Set evaluation context. Refresh the flags.
+     */
+    setContext: (context: ClientEvaluationContext) => Promise<void>;
+    /**
+     * Merge current evaluation context with the provided one. Refresh the flags.
+     */
+    updateContext: (context: ClientEvaluationContext) => Promise<void>;
+    /**
+     /**
+     * Get current context.
+     */
+    getContext: () => EvaluationContext;
+    /**
+     * Trigger a manual fetch of the environment features
+     */
+    getFlags: () => Promise<void>;
+    /**
+     * Returns the current flags
+     */
+    getAllFlags: () => IFlags<FKey<F>>;
+    /**
+     * Identify user, triggers a call to get flags if `flagsmith.init` has been called
+     * */
+    identify: (userId: string, traits?: Record<T, IFlagsmithValue>) => Promise<void>;
+    /**
+     * Retrieves the current state of flagsmith
+     */
+    getState: () => IState;
+    /**
+     * Set the current state of flagsmith
+     */
+    setState: (state: IState) => void;
+    /**
+     * Clears the identity, triggers a call to getFlags
+     */
+    logout: () => Promise<void>;
+    /**
+     * Polls the flagsmith API, specify interval in ms
+     */
+    startListening: (interval?: number) => void;
+    /**
+     * Stops polling
+     */
+    stopListening: () => void;
+    /**
+     * Returns whether a feature is enabled, or a fallback value if it does not exist.
+     * @param {HasFeatureOptions} [optionsOrSkipAnalytics=false] If `true`, will not track analytics for this flag
+     * evaluation. Using a boolean for this parameter is deprecated - use `{ skipAnalytics: true }` instead.
+     * @param [optionsOrSkipAnalytics.fallback=false] Returns this value if the feature does not exist.
+     * @param [optionsOrSkipAnalytics.skipAnalytics=false] If `true`, do not track analytics for this feature evaluation.
+     * @example
+     * flagsmith.hasFeature("power_user_feature")
+     * @example
+     * flagsmith.hasFeature("enabled_by_default_feature", { fallback: true })
+     */
+    hasFeature: (key: FKey<F>, optionsOrSkipAnalytics?: HasFeatureOptions) => boolean;
+
+    /**
+     * Returns the value of a feature, or a fallback value.
+     * @param [options.json=false] Deserialise the feature value using `JSON.parse` and return the result or `options.fallback`.
+     * @param [options.fallback=null] Return this value in any of these cases:
+     * * The feature does not exist.
+     * * The feature has no value.
+     * * `options.json` is `true` and the feature's value is not valid JSON.
+     * @param [options.skipAnalytics=false] If `true`, do not track analytics for this feature evaluation.
+     * @param [skipAnalytics=false] Deprecated - use `options.skipAnalytics` instead.
+     * @example
+     * flagsmith.getValue("remote_config") // "{\"hello\":\"world\"}"
+     * flagsmith.getValue("remote_config", { json: true }) // { hello: "world" }
+     * @example
+     * flagsmith.getValue("font_size") // "12px"
+     * flagsmith.getValue("font_size", { json: true, fallback: "8px" }) // "8px"
+     */
+    getValue<K extends FKey<F>>(
+        key: K,
+        options?: GetValueOptions<FValue<F, K>>,
+        skipAnalytics?: boolean
+    ): IFlagsmithValue<FValue<F, K>>;
+    /**
+     * Get the value of a particular trait for the identified user
+     */
+    getTrait: (key: T) => IFlagsmithValue;
+    /**
+     * Get the values of all traits for the identified user
+     */
+    getAllTraits: () => Record<string, IFlagsmithValue>;
+    /**
+     * Set a specific trait for a given user id, triggers a call to get flags
+     * */
+    setTrait: (key: T, value: IFlagsmithTrait) => Promise<void>;
+    /**
+     * Set a key value set of traits for a given user, triggers a call to get flags
+     */
+    setTraits: (traits: ITraits) => Promise<void>;
+    /**
+     * The stored identity of the user
+    */
+    identity?: IIdentity;
+    /**
+     * Whether the flagsmith SDK is initialised
+     */
+    initialised?: boolean;
+
+    /**
+     * Returns ths current loading state
+     */
+    loadingState?: LoadingState;
+
+    /**
+     * Used internally, this function will callback separately to onChange whenever flags are updated
+     */
+    _trigger?: () => void;
+    /**
+     * Used internally, this function will trigger the useFlagsmithLoading hook when loading state changes
+     */
+    _triggerLoadingState?: () => void;
+    /**
+     * Used internally, this is the cache options provided in flagsmith.init
+     */
+    cacheOptions: {
+        ttl: number;
+        skipAPI: boolean;
+        loadStale: boolean;
+    };
+    /**
+     * Used internally, this is the api provided in flagsmith.init, defaults to our production API
+     */
+    api: string
+}
+
+export {};

package/src/utils/angular-fetch.ts

@@ -0,0 +1,36 @@
+export default (angularHttpClient: any) => (url: string, params: { 
+    headers: Record<string, string>, 
+    method: "GET" | "POST" | "PUT", 
+    body?: string 
+}) => {
+    const { headers, method, body } = params;
+    const options = { headers, observe: 'response', responseType: 'text' };
+
+    const buildResponse = (response: any, ok: boolean) => {
+        const { status, headers, body, error, message } = response;
+        return {
+            status: status ?? (ok ? 200 : 500),
+            ok,
+            headers: { get: (name: string) => headers?.get?.(name) ?? null },
+            text: () => {
+                const value = body ?? error ?? message ?? '';
+                return Promise.resolve(typeof value !== 'string' ? JSON.stringify(value) : value);
+            },
+        };
+    };
+
+    return new Promise((resolve) => {
+        const onNext  = (res: any) => resolve(buildResponse(res, res.status ? res.status >= 200 && res.status < 300 : true));
+        const onError = (err: any) => resolve(buildResponse(err, false));
+        switch (method) {
+            case "GET":
+                return angularHttpClient.get(url, options).subscribe(onNext, onError);
+            case "POST":
+                return angularHttpClient.post(url, body ?? '', options).subscribe(onNext, onError);
+            case "PUT":
+                return angularHttpClient.post(url, body ?? '', options).subscribe(onNext, onError);
+            default:
+                return onError({ status: 405, message: `Unsupported method: ${method}` });
+        }   
+    });
+};