@flagsmith/flagsmith 11.0.0-internal.1

package/src/utils/async-storage.ts

@@ -0,0 +1,41 @@
+export type AsyncStorageType = {
+    getItemSync?: (key:string)=>string|null
+    getItem: (key:string, cb?:(err:Error|null, res:string|null)=>void)=>Promise<string|null>
+    setItem: (key:string, value: string)=>Promise<string|null>
+} | null
+const AsyncStorage: AsyncStorageType = {
+    getItemSync: function(key) {
+        try {
+            const data = localStorage.getItem(key);
+            return data || null
+        } catch (e) {
+            return null
+        }
+    },
+    getItem: function (key, cb) {
+        return new Promise<any>((resolve, reject) => {
+            try {
+                const result = this.getItemSync!(key);
+                cb?.(null, result)
+                resolve(result)
+            } catch (err) {
+                cb && cb(err as Error, null);
+                reject(err);
+            }
+        });
+    },
+    setItem: function (key:string, value:string, cb?: (err:Error|null, res:string|null)=>void) {
+        return new Promise<any>((resolve, reject) => {
+            try {
+                localStorage.setItem(key, value);
+                cb && cb(null, value);
+                resolve(value);
+            } catch (err) {
+                cb && cb(err as Error, null);
+                reject(err);
+            }
+        });
+    }
+};
+
+export default AsyncStorage

package/src/utils/emitter.ts

@@ -0,0 +1,90 @@
+interface EventCallback {
+    id: string;
+    fn: () => void;
+    ctx?: any;
+}
+
+type EventName = string;
+
+interface EventMap {
+    [eventName: string]: EventCallback[];
+}
+
+class Emitter {
+    private e: EventMap = {};
+
+    private generateCallbackId(): string {
+        return Math.random().toString(36).substring(7);
+    }
+
+    on(name: EventName, callback: () => void, ctx?: any): () => this {
+        const e = this.e || (this.e = {});
+        const id = this.generateCallbackId();
+
+        const listener = {
+            id: id,
+            fn: callback,
+            ctx: ctx
+        };
+
+        (e[name] || (e[name] = [])).push(listener);
+
+        const offFunction = () => {
+            this.off(name, id);
+        };
+
+        return offFunction.bind(this) as () => this;
+    }
+
+    once(
+        name: string, // EventName inlined as string
+        callback: (...args: any[]) => void,
+        ctx?: any
+    ): () => this {
+        const self = this;
+        const id = this.generateCallbackId();
+
+        function listener(this: unknown, ...args: any[]) {
+            self.off(name, id);
+            callback.apply(ctx, args);
+        }
+
+        (listener as any)._ = callback;
+
+        return this.on(name, listener, ctx) as () => this;
+    }
+
+    emit(name: EventName, ...data: any[]): this {
+        const evtArr = ((this.e || (this.e = {}))[name] || []).slice();
+        const len = evtArr.length;
+
+        for (let i = 0; i < len; i++) {
+            evtArr[i].fn.apply(evtArr[i].ctx, data as any);
+        }
+
+        return this;
+    }
+
+    off(name: EventName, callbackOrId?: (() => void) | string, ctx?: any): this {
+        const e = this.e || (this.e = {});
+        const evts = e[name];
+        const liveEvents: EventCallback[] = [];
+
+        if (evts && callbackOrId) {
+            for (let i = 0, len = evts.length; i < len; i++) {
+                if (
+                    (typeof callbackOrId === 'function' && evts[i].fn !== callbackOrId) ||
+                    (typeof callbackOrId === 'string' && evts[i].id !== callbackOrId)
+                ) {
+                    liveEvents.push(evts[i]);
+                }
+            }
+        }
+
+        (liveEvents.length ? e[name] = liveEvents : delete e[name]);
+
+        return this;
+    }
+}
+
+export default Emitter;

package/src/utils/ensureTrailingSlash.ts

@@ -0,0 +1,3 @@
+export function ensureTrailingSlash(str: string): string {
+    return str.endsWith('/') ? str : str + '/';
+}

package/src/utils/get-changes.ts

@@ -0,0 +1,19 @@
+import { IFlags, Traits } from '../types';
+import deepEqual from 'fast-deep-equal';
+
+export default function(before: Traits | IFlags | undefined | null, after:Traits | IFlags | undefined | null) {
+    const changedValues = Object.keys(after||{}).filter((flagKey)=>{
+        const beforeValue = before?.[flagKey]
+        const afterValue = after?.[flagKey]
+        return !deepEqual(beforeValue, afterValue)
+    })
+    Object.keys(before||{}).filter((flagKey)=>{
+        if(!Object.keys(after||{}).includes(flagKey)) {
+            changedValues.push(flagKey)
+        }
+    })
+    if (!Object.keys(changedValues).length) {
+        return null
+    }
+    return changedValues
+}

package/src/utils/set-dynatrace-value.ts

@@ -0,0 +1,15 @@
+// transforms any trait to match sendSessionProperties
+// https://www.dynatrace.com/support/doc/javascriptapi/interfaces/dtrum_types.DtrumApi.html#addActionProperties
+import { DynatraceObject } from '../types';
+export default function (obj: DynatraceObject, trait: string, value: string|number|boolean|null|undefined) {
+    let key: keyof DynatraceObject= 'shortString'
+    let convertToString = true
+    if (typeof value === 'number') {
+        key = 'javaDouble'
+        convertToString = false
+    }
+    // @ts-expect-error
+    obj[key] = obj[key] || {}
+    // @ts-expect-error
+    obj[key][trait] = convertToString ? value+"":value
+}

package/src/utils/types.ts

@@ -0,0 +1,24 @@
+import { EvaluationContext, TraitEvaluationContext } from "../evaluation-context";
+import { ClientEvaluationContext, ITraits, IFlagsmithTrait } from "../types";
+
+export function isTraitEvaluationContext(trait: TraitEvaluationContext | IFlagsmithTrait): trait is TraitEvaluationContext {
+    return !!trait && typeof trait == 'object' && trait.value !== undefined;
+}
+
+export function toTraitEvaluationContextObject(traits: ITraits): { [key: string]: null | TraitEvaluationContext } {
+    return Object.fromEntries(
+        Object.entries(traits).map(
+            ([tKey, tValue]) => [tKey, isTraitEvaluationContext(tValue) ? tValue : {value: tValue}]
+        )
+    );
+}
+
+export function toEvaluationContext(clientEvaluationContext: ClientEvaluationContext): EvaluationContext {
+    return {
+        ...clientEvaluationContext,
+        identity: !!clientEvaluationContext.identity ? {
+            ...clientEvaluationContext.identity,
+            traits: toTraitEvaluationContextObject(clientEvaluationContext.identity.traits || {})
+        } : undefined,
+    }
+}

package/src/utils/version.ts

@@ -0,0 +1,2 @@
+// Auto-generated by write-version.js
+export const SDK_VERSION = "11.0.0-internal.1";

package/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/utils/angular-fetch.d.ts

@@ -0,0 +1,6 @@
+declare const _default: (angularHttpClient: any) => (url: string, params: {
+    headers: Record<string, string>;
+    method: "GET" | "POST" | "PUT";
+    body?: string | undefined;
+}) => Promise<unknown>;
+export default _default;

package/utils/async-storage.d.ts

@@ -0,0 +1,7 @@
+export type AsyncStorageType = {
+    getItemSync?: (key: string) => string | null;
+    getItem: (key: string, cb?: (err: Error | null, res: string | null) => void) => Promise<string | null>;
+    setItem: (key: string, value: string) => Promise<string | null>;
+} | null;
+declare const AsyncStorage: AsyncStorageType;
+export default AsyncStorage;

package/utils/emitter.d.ts

@@ -0,0 +1,11 @@
+type EventName = string;
+declare class Emitter {
+    private e;
+    private generateCallbackId;
+    on(name: EventName, callback: () => void, ctx?: any): () => this;
+    once(name: string, // EventName inlined as string
+    callback: (...args: any[]) => void, ctx?: any): () => this;
+    emit(name: EventName, ...data: any[]): this;
+    off(name: EventName, callbackOrId?: (() => void) | string, ctx?: any): this;
+}
+export default Emitter;

package/utils/ensureTrailingSlash.d.ts

@@ -0,0 +1 @@
+export declare function ensureTrailingSlash(str: string): string;

package/utils/get-changes.d.ts

@@ -0,0 +1,2 @@
+import { IFlags, Traits } from '../types';
+export default function (before: Traits | IFlags | undefined | null, after: Traits | IFlags | undefined | null): string[] | null;

package/utils/set-dynatrace-value.d.ts

@@ -0,0 +1,2 @@
+import { DynatraceObject } from '../types';
+export default function (obj: DynatraceObject, trait: string, value: string | number | boolean | null | undefined): void;

package/utils/types.d.ts

@@ -0,0 +1,7 @@
+import { EvaluationContext, TraitEvaluationContext } from "../evaluation-context";
+import { ClientEvaluationContext, ITraits, IFlagsmithTrait } from "../types";
+export declare function isTraitEvaluationContext(trait: TraitEvaluationContext | IFlagsmithTrait): trait is TraitEvaluationContext;
+export declare function toTraitEvaluationContextObject(traits: ITraits): {
+    [key: string]: null | TraitEvaluationContext;
+};
+export declare function toEvaluationContext(clientEvaluationContext: ClientEvaluationContext): EvaluationContext;

package/utils/version.d.ts

@@ -0,0 +1 @@
+export declare const SDK_VERSION = "11.0.0-internal.1";