@dynamic-labs-sdk/client 0.0.1-alpha.1

package/index.esm.js

@@ -0,0 +1,522 @@
+import { SDKApi, Configuration } from '@dynamic-labs/sdk-api-core';
+import EventEmitter$1, { EventEmitter } from 'eventemitter3';
+
+const getCore = (client)=>{
+    // @ts-expect-error - this was hidden from the public API
+    return client.__core;
+};
+
+function _extends() {
+    _extends = Object.assign || function assign(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source)if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
+        }
+        return target;
+    };
+    return _extends.apply(this, arguments);
+}
+
+var version = "0.0.1-alpha.1";
+var dependencies = {
+    "@dynamic-labs/sdk-api-core": "0.0.630"};
+
+/**
+ * Returns a new instance of the SDK API client.
+ *
+ * This is not meant for storing, as it is very light we can create it whenever needed.
+ */ const createApiClient = (client)=>{
+    const core = getCore(client);
+    const settings = {
+        basePath: core.apiBaseUrl,
+        headers: {
+            'Content-Type': 'application/json',
+            'x-dyn-api-version': dependencies['@dynamic-labs/sdk-api-core'],
+            'x-dyn-version': core.version
+        }
+    };
+    if (client.token) {
+        settings.headers.Authorization = `Bearer ${client.token}`;
+    }
+    return new SDKApi(new Configuration(_extends({}, settings, {
+        fetchApi: core.fetch
+    })));
+};
+
+/**
+ * Updates the project settings in the core state to the latest values.
+ */ const fetchProjectSettings = async (client)=>{
+    const core = getCore(client);
+    const apiClient = createApiClient(client);
+    const projectSettings = await apiClient.getEnvironmentSettings({
+        environmentId: core.environmentId,
+        sdkVersion: `WalletKit/${core.version}`
+    }, {
+        credentials: 'omit'
+    });
+    core.state.set({
+        projectSettings
+    });
+    return projectSettings;
+};
+
+const getDetails = ({ details, cause })=>{
+    if (cause instanceof BaseError) {
+        return cause.details;
+    }
+    if (cause == null ? void 0 : cause.message) {
+        return cause.message;
+    }
+    return details;
+};
+/**
+ * Formats the error message with all available information
+ */ const formatMessage = ({ shortMessage, details, docsUrl, metaMessages })=>{
+    return [
+        shortMessage,
+        '',
+        ...metaMessages ? [
+            ...metaMessages,
+            ''
+        ] : [],
+        ...docsUrl ? [
+            `Docs: ${docsUrl}`
+        ] : [],
+        ...details ? [
+            `Details: ${details}`
+        ] : [],
+        `Version: ${version}`,
+        `Timestamp: ${new Date().toISOString()}`
+    ].join('\n');
+};
+/**
+ * Base error class that provides structured error handling with detailed information
+ */ class BaseError extends Error {
+    /**
+   * Walks the cause chain of the error and returns the root error
+   */ walk() {
+        const cause = this.cause;
+        if (cause instanceof BaseError) {
+            return cause.walk();
+        }
+        return cause;
+    }
+    constructor(args){
+        const details = getDetails(args);
+        super(formatMessage(_extends({}, args, {
+            details
+        })), args.cause ? {
+            cause: args.cause
+        } : undefined);
+        this.name = 'BaseError';
+        this.details = details;
+        var _args_name;
+        this.name = (_args_name = args.name) != null ? _args_name : this.name;
+        var _args_cause;
+        this.cause = (_args_cause = args.cause) != null ? _args_cause : this.cause;
+    }
+}
+
+class ClientAlreadyInitializedError extends BaseError {
+    constructor(){
+        super({
+            cause: null,
+            docsUrl: null,
+            name: 'ClientAlreadyInitializedError',
+            shortMessage: 'Client must not be initialized more than once'
+        });
+    }
+}
+
+/**
+ * Orchestrates the initialization of all modules and services of the SDK, and keeps
+ * the loading flag updated.
+ */ const initializeClient = async (client)=>{
+    const core = getCore(client);
+    if (core.state.get().initStatus !== 'uninitialized') {
+        throw new ClientAlreadyInitializedError();
+    }
+    core.state.set({
+        initStatus: 'in-progress'
+    });
+    const projectSettingsPromise = fetchProjectSettings(client);
+    core.initTrack.track({
+        name: 'project-settings',
+        promise: projectSettingsPromise
+    });
+    try {
+        await core.initTrack.waitForAll();
+        core.state.set({
+            initStatus: 'finished'
+        });
+    } catch (error) {
+        core.state.set({
+            initStatus: 'failed'
+        });
+        throw error;
+    }
+};
+
+const createDeferredPromise = ()=>{
+    let resolve;
+    let reject;
+    const promise = new Promise((_resolve, _reject)=>{
+        resolve = _resolve;
+        reject = _reject;
+    });
+    return {
+        promise,
+        reject: (reason)=>reject == null ? void 0 : reject(reason),
+        resolve: (value)=>resolve == null ? void 0 : resolve(value)
+    };
+};
+
+class CannotTrackError extends BaseError {
+    constructor(){
+        super({
+            cause: null,
+            docsUrl: null,
+            name: 'CannotTrackError',
+            shortMessage: 'All track calls must be performed in the same node tick'
+        });
+    }
+}
+
+/**
+ * Creates a tracker that associates names with promises and raises as promises resolve.
+ */ const createAsyncTrack = ()=>{
+    /**
+   * Whether tracking is enabled.
+   * All processes must be tracked on the same node tick.
+   *
+   * This ensures no process is missed (as it would throw when tracked on a different node tick).
+   */ let isTrackEnabled = true;
+    const eventEmitter = new EventEmitter();
+    const allSettledPromise = createDeferredPromise();
+    const tracker = new Map();
+    /**
+   * Checks if all processes are initialized and resolves the main promise if they are.
+   */ const checkIfAllSettled = ()=>{
+        const allSettled = Array.from(tracker.values()).every((status)=>status === 'resolved');
+        if (!allSettled) return;
+        allSettledPromise.resolve();
+    };
+    const track = ({ name, promise })=>{
+        if (!isTrackEnabled) {
+            throw new CannotTrackError();
+        }
+        // Disable tracking in the next node tick
+        void Promise.resolve().then(()=>isTrackEnabled = false);
+        tracker.set(name, 'pending');
+        promise.then(()=>{
+            tracker.set(name, 'resolved');
+            eventEmitter.emit('resolved', name);
+            checkIfAllSettled();
+        }).catch((error)=>{
+            tracker.set(name, 'failed');
+            eventEmitter.emit('failed', name, error);
+            allSettledPromise.reject(error);
+        });
+    };
+    const waitForAll = ()=>allSettledPromise.promise;
+    const getTracker = ()=>tracker;
+    return {
+        getTracker,
+        off: eventEmitter.off.bind(eventEmitter),
+        on: eventEmitter.on.bind(eventEmitter),
+        track,
+        waitForAll
+    };
+};
+
+const createEventEmitter = ()=>new EventEmitter$1();
+
+/**
+ * Creates a fetch instance that uses the native window.fetch API.
+ */ // eslint-disable-next-line no-restricted-globals -- this is the abstraction for fetch
+const createWebFetch = ()=>window.fetch;
+
+/**
+ * Log levels and their corresponding numeric values
+ */ const LOG_LEVELS = {
+    debug: 0,
+    error: 3,
+    info: 1,
+    warn: 2
+};
+// Assign to avoid lint errors
+const defaultConsole = console;
+/**
+ * Creates a logger instance with configurable log level and event emission capabilities.
+ * @returns A logger instance with debug, info, warn, and error methods
+ */ const createLogger = (options = {})=>{
+    const eventEmitter = new EventEmitter();
+    var _options_level;
+    // Default to 'debug' if no level is provided
+    const minLevel = (_options_level = options.level) != null ? _options_level : 'warn';
+    // Helper to decide if we should log based on current log level
+    const shouldLog = (level)=>{
+        return LOG_LEVELS[level] >= LOG_LEVELS[minLevel];
+    };
+    // Helper to format the log message
+    const formatMessage = (level, message)=>{
+        const timestamp = new Date().toISOString();
+        return `[${timestamp}] ${level.toUpperCase()}: ${message}`;
+    };
+    // Unified logger function that checks the level and calls the appropriate console method
+    const log = (level, consoleMethod, message, ...args)=>{
+        eventEmitter.emit('log', level, message, ...args);
+        if (!shouldLog(level)) return;
+        consoleMethod(formatMessage(level, message), ...args);
+    };
+    return {
+        debug: (message, ...args)=>log('debug', defaultConsole.debug, message, ...args),
+        error: (message, ...args)=>log('error', defaultConsole.error, message, ...args),
+        info: (message, ...args)=>log('info', defaultConsole.info, message, ...args),
+        off: eventEmitter.off.bind(eventEmitter),
+        on: eventEmitter.on.bind(eventEmitter),
+        warn: (message, ...args)=>log('warn', defaultConsole.warn, message, ...args)
+    };
+};
+
+/**
+ * Creates a deeplink opener that uses the native window.open API.
+ */ const createWebDeeplinkOpener = ()=>{
+    return async (url)=>{
+        // eslint-disable-next-line no-restricted-globals -- this is the abstraction for opening a deeplink
+        window.open(url, '_blank');
+    };
+};
+
+const formatForStorage = (value)=>{
+    const item = {
+        value
+    };
+    return JSON.stringify(item);
+};
+const parseFromStorage = (value)=>{
+    const item = JSON.parse(value);
+    return item.value;
+};
+
+/**
+ * Creates a Storage instance that uses localStorage as the storage model meant for use in the browser.
+ */ const createWebStorage = ()=>({
+        getItem: async (key)=>{
+            const rawItem = localStorage.getItem(key);
+            return rawItem ? parseFromStorage(rawItem) : null;
+        },
+        removeItem: async (key)=>{
+            localStorage.removeItem(key);
+        },
+        setItem: async (key, value)=>{
+            const item = formatForStorage(value);
+            localStorage.setItem(key, item);
+        }
+    });
+
+const createObservableState = (getInitialState)=>{
+    // ===============
+    // NOTIFICATIONS
+    // ===============
+    const subscribers = new Set();
+    const notifySubscribers = (value)=>{
+        subscribers.forEach((callback)=>callback(value));
+    };
+    const subscribe = (callback)=>{
+        subscribers.add(callback);
+        return ()=>unsubscribe(callback);
+    };
+    const unsubscribe = (callback)=>{
+        subscribers.delete(callback);
+    };
+    // ===============
+    // STATE
+    // ===============
+    const currentValue = getInitialState();
+    const get = ()=>currentValue;
+    const set = (partial)=>{
+        Object.assign(currentValue, partial);
+        notifySubscribers(currentValue);
+    };
+    return {
+        get,
+        getInitialState,
+        set,
+        subscribe,
+        unsubscribe
+    };
+};
+
+/**
+ * The default API base URL for Dynamic apps in production.
+ */ const DEFAULT_API_BASE_URL = 'https://app.dynamic.xyz/api/v0';
+
+/**
+ * Creates a core instance that contains all the services and state of the Dynamic SDK client.
+ */ const createCore = (config)=>{
+    var _config_coreConfig, _config_coreConfig1, _config_coreConfig2, _config_coreConfig3, _config_coreConfig4;
+    var _config_coreConfig_apiBaseUrl;
+    const apiBaseUrl = (_config_coreConfig_apiBaseUrl = (_config_coreConfig = config.coreConfig) == null ? void 0 : _config_coreConfig.apiBaseUrl) != null ? _config_coreConfig_apiBaseUrl : DEFAULT_API_BASE_URL;
+    var _config_coreConfig_logger;
+    const logger = (_config_coreConfig_logger = (_config_coreConfig1 = config.coreConfig) == null ? void 0 : _config_coreConfig1.logger) != null ? _config_coreConfig_logger : createLogger();
+    var _config_coreConfig_storage;
+    const storage = (_config_coreConfig_storage = (_config_coreConfig2 = config.coreConfig) == null ? void 0 : _config_coreConfig2.storage) != null ? _config_coreConfig_storage : createWebStorage();
+    var _config_coreConfig_fetch;
+    const fetch = (_config_coreConfig_fetch = (_config_coreConfig3 = config.coreConfig) == null ? void 0 : _config_coreConfig3.fetch) != null ? _config_coreConfig_fetch : createWebFetch();
+    var _config_coreConfig_openDeeplink;
+    const openDeeplink = (_config_coreConfig_openDeeplink = (_config_coreConfig4 = config.coreConfig) == null ? void 0 : _config_coreConfig4.openDeeplink) != null ? _config_coreConfig_openDeeplink : createWebDeeplinkOpener();
+    const state = createObservableState(()=>({
+            initStatus: 'uninitialized',
+            loaded: false,
+            projectSettings: null,
+            token: null,
+            user: null
+        }));
+    const eventEmitter = createEventEmitter();
+    const initTrack = createAsyncTrack();
+    return {
+        apiBaseUrl,
+        environmentId: config.environmentId,
+        eventEmitter,
+        fetch,
+        initTrack,
+        logger,
+        openDeeplink,
+        state,
+        storage,
+        version
+    };
+};
+
+const createDynamicClient = (config)=>{
+    const core = createCore(config);
+    const client = {
+        get __core () {
+            return core;
+        },
+        get initStatus () {
+            return core.state.get().initStatus;
+        },
+        get projectSettings () {
+            return core.state.get().projectSettings;
+        },
+        get token () {
+            return core.state.get().token;
+        },
+        get user () {
+            return core.state.get().user;
+        }
+    };
+    var _config_autoInitialize;
+    const autoInitialize = (_config_autoInitialize = config.autoInitialize) != null ? _config_autoInitialize : true;
+    if (autoInitialize) {
+        void initializeClient(client);
+    }
+    return client;
+};
+
+const logout = async (client)=>{
+    const core = getCore(client);
+    const apiClient = createApiClient(client);
+    await apiClient.revokeSession({
+        environmentId: core.environmentId
+    });
+    core.state.set({
+        token: null,
+        user: null
+    });
+};
+
+/**
+ * Listen to an event from the client.
+ *
+ * @returns A function that can be called to remove the listener.
+ */ const onEvent = (client, event, listener)=>{
+    const { eventEmitter } = getCore(client);
+    eventEmitter.on(event, listener);
+    return ()=>{
+        eventEmitter.off(event, listener);
+    };
+};
+/**
+ * Remove a listener from an event.
+ */ const offEvent = (client, event, listener)=>{
+    const { eventEmitter } = getCore(client);
+    eventEmitter.off(event, listener);
+};
+/**
+ * Listen to an event that will only fire once.
+ *
+ * @returns A function that can be called to remove the listener.
+ */ const onceEvent = (client, event, listener)=>{
+    const { eventEmitter } = getCore(client);
+    eventEmitter.once(event, listener);
+    return ()=>{
+        eventEmitter.off(event, listener);
+    };
+};
+
+const assignClient = (target, client)=>{
+    Object.defineProperty(target, '__client', {
+        // hide from enumeration
+        configurable: true,
+        enumerable: false,
+        get: ()=>client
+    });
+    return target;
+};
+
+class ClientNotPresentError extends BaseError {
+    constructor(){
+        super({
+            cause: null,
+            docsUrl: null,
+            name: 'ClientNotPresentError',
+            shortMessage: 'The client is not present in the target object.'
+        });
+    }
+}
+
+const getClient = (target)=>{
+    if (!Object.prototype.hasOwnProperty.call(target, '__client')) {
+        throw new ClientNotPresentError();
+    }
+    // @ts-expect-error - this was hidden from the public API
+    return target.__client;
+};
+
+const sendEmailOTP = async (client, { email })=>{
+    const core = getCore(client);
+    const apiClient = createApiClient(client);
+    const { verificationUUID } = await apiClient.createEmailVerification({
+        emailVerificationCreateRequest: {
+            email
+        },
+        environmentId: core.environmentId
+    });
+    return assignClient({
+        email,
+        verificationUUID
+    }, client);
+};
+
+const verifyOTP = async (otpVerification, { verificationToken })=>{
+    const client = getClient(otpVerification);
+    const core = getCore(client);
+    const apiClient = createApiClient(client);
+    const { user, minifiedJwt } = await apiClient.signInWithEmailVerification({
+        emailVerificationVerifyRequest: {
+            verificationToken,
+            verificationUUID: otpVerification.verificationUUID
+        },
+        environmentId: core.environmentId
+    });
+    core.state.set({
+        token: minifiedJwt,
+        user
+    });
+    return user;
+};
+
+export { createDynamicClient, logout, offEvent, onEvent, onceEvent, sendEmailOTP, verifyOTP };

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@dynamic-labs-sdk/client",
+  "version": "0.0.1-alpha.1",
+  "type": "module",
+  "main": "./index.esm.js",
+  "module": "./index.esm.js",
+  "types": "./index.esm.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./index.esm.d.ts",
+      "import": "./index.esm.js",
+      "default": "./index.esm.js"
+    }
+  },
+  "dependencies": {
+    "@dynamic-labs/sdk-api-core": "0.0.630",
+    "eventemitter3": "^5.0.1"
+  }
+}

package/src/client/consts.d.ts

@@ -0,0 +1,5 @@
+/**
+ * The default API base URL for Dynamic apps in production.
+ */
+export declare const DEFAULT_API_BASE_URL = "https://app.dynamic.xyz/api/v0";
+//# sourceMappingURL=consts.d.ts.map

package/src/client/consts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consts.d.ts","sourceRoot":"","sources":["../../../../../packages/client/src/client/consts.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,oBAAoB,mCAAmC,CAAC"}

package/src/client/createCore/createCore.d.ts

@@ -0,0 +1,7 @@
+import type { DynamicClientConfig } from '../types';
+import type { DynamicCore } from './types';
+/**
+ * Creates a core instance that contains all the services and state of the Dynamic SDK client.
+ */
+export declare const createCore: (config: DynamicClientConfig) => DynamicCore;
+//# sourceMappingURL=createCore.d.ts.map

package/src/client/createCore/createCore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createCore.d.ts","sourceRoot":"","sources":["../../../../../../packages/client/src/client/createCore/createCore.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AACpD,OAAO,KAAK,EAAE,WAAW,EAAoB,MAAM,SAAS,CAAC;AAE7D;;GAEG;AACH,eAAO,MAAM,UAAU,WAAY,mBAAmB,KAAG,WAqCxD,CAAC"}

package/src/client/createCore/index.d.ts

@@ -0,0 +1,2 @@
+export { createCore } from './createCore';
+//# sourceMappingURL=index.d.ts.map

package/src/client/createCore/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../packages/client/src/client/createCore/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC"}

package/src/client/createCore/types/DynamicCore.d.ts

@@ -0,0 +1,56 @@
+import type EventEmitter from 'eventemitter3';
+import type { AsyncTrack } from '../../../services/asyncTrack';
+import type { Fetch } from '../../../services/fetch';
+import type { Logger } from '../../../services/logger';
+import type { OpenDeeplink } from '../../../services/openDeeplink';
+import type { Storage } from '../../../services/storage/types';
+import type { ObservableState } from '../../../utils/observable/types';
+import type { DynamicCoreState } from './DynamicCoreState';
+/**
+ * The core object needed to work with Dynamic SDK's functionality.
+ *
+ * Holds all state and services any module might need to use.
+ */
+export type DynamicCore = {
+    /**
+     * The base URL to use for API requests to Dynamic.
+     */
+    apiBaseUrl: string;
+    /**
+     * The environment ID of the Dynamic app.
+     */
+    environmentId: string;
+    /**
+     * A generic event emitter instance for handling events.
+     */
+    eventEmitter: EventEmitter;
+    /**
+     * Instance of the fetch service, used for making any HTTP requests.
+     */
+    fetch: Fetch;
+    /**
+     * Instance of the async track service, used for tracking status of SDK initialization promises.
+     */
+    initTrack: AsyncTrack;
+    /**
+     * Instance of the logger service, used for logging messages to the console and controlling the log level.
+     */
+    logger: Logger;
+    /**
+     * Instance of the open deeplink service, used for triggering deeplinks using the appropriate device method.
+     */
+    openDeeplink: OpenDeeplink;
+    /**
+     * Reactive object with all variable state of the client.
+     */
+    state: ObservableState<DynamicCoreState>;
+    /**
+     * Instance of the storage service, used for interacting with the device's storage.
+     */
+    storage: Storage<DynamicCoreState>;
+    /**
+     * The NPM version of the Dynamic SDK client package.
+     */
+    version: string;
+};
+//# sourceMappingURL=DynamicCore.d.ts.map

package/src/client/createCore/types/DynamicCore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DynamicCore.d.ts","sourceRoot":"","sources":["../../../../../../../packages/client/src/client/createCore/types/DynamicCore.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,YAAY,MAAM,eAAe,CAAC;AAE9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAC/D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AACrD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AACnE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iCAAiC,CAAC;AAC/D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AACvE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE3D;;;;GAIG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,aAAa,EAAE,MAAM,CAAC;IAEtB;;OAEG;IACH,YAAY,EAAE,YAAY,CAAC;IAE3B;;OAEG;IACH,KAAK,EAAE,KAAK,CAAC;IAEb;;OAEG;IACH,SAAS,EAAE,UAAU,CAAC;IAEtB;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,YAAY,EAAE,YAAY,CAAC;IAE3B;;OAEG;IACH,KAAK,EAAE,eAAe,CAAC,gBAAgB,CAAC,CAAC;IAEzC;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAEnC;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC"}

package/src/client/createCore/types/DynamicCoreConfig.d.ts

@@ -0,0 +1,6 @@
+import type { DynamicCore } from './DynamicCore';
+/**
+ * Available options for internal configuration of the Dynamic SDK client.
+ */
+export type DynamicCoreConfig = Partial<Pick<DynamicCore, 'apiBaseUrl' | 'fetch' | 'logger' | 'openDeeplink' | 'storage'>>;
+//# sourceMappingURL=DynamicCoreConfig.d.ts.map

package/src/client/createCore/types/DynamicCoreConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DynamicCoreConfig.d.ts","sourceRoot":"","sources":["../../../../../../../packages/client/src/client/createCore/types/DynamicCoreConfig.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,OAAO,CACrC,IAAI,CACF,WAAW,EACX,YAAY,GAAG,OAAO,GAAG,QAAQ,GAAG,cAAc,GAAG,SAAS,CAC/D,CACF,CAAC"}

package/src/client/createCore/types/DynamicCoreState.d.ts

@@ -0,0 +1,30 @@
+import type { ProjectSettings } from '@dynamic-labs/sdk-api-core';
+import type { User } from 'src/modules/user/types';
+export type DynamicInitStatus = 'uninitialized' | 'in-progress' | 'finished' | 'failed';
+/**
+ * Object with all variable state of the client
+ */
+export type DynamicCoreState = {
+    /**
+     * Status of client initialization.
+     *
+     * - `uninitialized`: Initialization has not started yet.
+     * - `in-progress`: Initialization is in progress.
+     * - `finished`: Initialization has finished successfully.
+     * - `failed`: Initialization failed. Check console logs for more details.
+     */
+    initStatus: DynamicInitStatus;
+    /**
+     * The settings of the Dynamic project as configured in dashboard.
+     */
+    projectSettings: ProjectSettings | null;
+    /**
+     * The JWT of the current user.
+     */
+    token: string | null;
+    /**
+     * The current user of the app.
+     */
+    user: User | null;
+};
+//# sourceMappingURL=DynamicCoreState.d.ts.map

package/src/client/createCore/types/DynamicCoreState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DynamicCoreState.d.ts","sourceRoot":"","sources":["../../../../../../../packages/client/src/client/createCore/types/DynamicCoreState.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAClE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,wBAAwB,CAAC;AAEnD,MAAM,MAAM,iBAAiB,GACzB,eAAe,GACf,aAAa,GACb,UAAU,GACV,QAAQ,CAAC;AAEb;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B;;;;;;;OAOG;IACH,UAAU,EAAE,iBAAiB,CAAC;IAE9B;;OAEG;IACH,eAAe,EAAE,eAAe,GAAG,IAAI,CAAC;IAExC;;OAEG;IACH,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAErB;;OAEG;IACH,IAAI,EAAE,IAAI,GAAG,IAAI,CAAC;CACnB,CAAC"}

package/src/client/createCore/types/index.d.ts

@@ -0,0 +1,4 @@
+export type { DynamicCore } from './DynamicCore';
+export type { DynamicCoreConfig } from './DynamicCoreConfig';
+export type { DynamicCoreState, DynamicInitStatus } from './DynamicCoreState';
+//# sourceMappingURL=index.d.ts.map

package/src/client/createCore/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../packages/client/src/client/createCore/types/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACjD,YAAY,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAC7D,YAAY,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC"}