@croct/plug 0.16.5 → 0.17.1

package/plug.d.ts

@@ -2,24 +2,37 @@ import { SessionFacade } from '@croct/sdk/facade/sessionFacade';
 import { UserFacade } from '@croct/sdk/facade/userFacade';
 import { TrackerFacade } from '@croct/sdk/facade/trackerFacade';
 import { EvaluationOptions, EvaluatorFacade } from '@croct/sdk/facade/evaluatorFacade';
-import { Configuration as SdkFacadeConfiguration } from '@croct/sdk/facade/sdkFacade';
+import { Configuration as Configuration$1 } from '@croct/sdk/facade/sdkFacade';
 import { Optional } from '@croct/sdk/utilityTypes';
-import { ExternalTrackingEvent as ExternalEvent, ExternalTrackingEventPayload as ExternalEventPayload, ExternalTrackingEventType as ExternalEventType } from '@croct/sdk/trackingEvents';
-import { FetchOptions as BaseFetchOptions } from '@croct/sdk/facade/contentFetcherFacade';
-import { PluginFactory } from './plugin';
-import { VersionedSlotId, SlotContent } from './slot';
-import { JsonValue, JsonObject } from './sdk/json';
-export interface PluginConfigurations {
+import { ExternalTrackingEventType, ExternalTrackingEventPayload, ExternalTrackingEvent } from '@croct/sdk/trackingEvents';
+import { FetchOptions as FetchOptions$1 } from '@croct/sdk/facade/contentFetcherFacade';
+import { PluginFactory } from './plugin.js';
+import { VersionedSlotId, SlotContent } from './slot.js';
+import { JsonValue, JsonObject } from '@croct/json/mutable';
+import '@croct/sdk/token';
+import './sdk/index.js';
+import '@croct/sdk/eventManager';
+import '@croct/sdk/sdkEvents';
+import '@croct/sdk/logging';
+import '@croct/sdk/tab';
+import '@croct/sdk/cid';
+import '@croct/json';
+import './versioning.js';
+import './component.js';
+
+interface PluginConfigurations {
     [key: string]: any;
 }
-export type Configuration = Optional<SdkFacadeConfiguration, 'appId'> & {
+type Configuration = Optional<Configuration$1, 'appId'> & {
     plugins?: PluginConfigurations;
 };
-export type FetchOptions = Omit<BaseFetchOptions, 'version'>;
-export type FetchResponse<I extends VersionedSlotId, C extends JsonObject = JsonObject> = {
-    content: SlotContent<I, C>;
+type FetchOptions<T> = Omit<FetchOptions$1, 'version'> & {
+    fallback?: T;
 };
-export interface Plug {
+type FetchResponse<I extends VersionedSlotId, C extends JsonObject = JsonObject, F = never> = {
+    content: SlotContent<I, C> | F;
+};
+interface Plug {
     readonly tracker: TrackerFacade;
     readonly user: UserFacade;
     readonly session: SessionFacade;
@@ -33,12 +46,13 @@ export interface Plug {
     anonymize(): void;
     setToken(token: string): void;
     unsetToken(): void;
-    track<T extends ExternalEventType>(type: T, payload: ExternalEventPayload<T>): Promise<ExternalEvent<T>>;
+    track<T extends ExternalTrackingEventType>(type: T, payload: ExternalTrackingEventPayload<T>): Promise<ExternalTrackingEvent<T>>;
     evaluate<T extends JsonValue>(expression: string, options?: EvaluationOptions): Promise<T>;
-    fetch<P extends JsonObject, I extends VersionedSlotId>(slotId: I, options?: FetchOptions): Promise<FetchResponse<I, P>>;
+    fetch<I extends VersionedSlotId>(slotId: I, options?: FetchOptions<SlotContent<I>>): Promise<FetchResponse<I>>;
+    fetch<F, I extends VersionedSlotId>(slotId: I, options?: FetchOptions<SlotContent<I> | F>): Promise<FetchResponse<I, JsonObject, F>>;
     unplug(): Promise<void>;
 }
-export declare class GlobalPlug implements Plug {
+declare class GlobalPlug implements Plug {
     private pluginFactories;
     private instance?;
     private plugins;
@@ -61,9 +75,12 @@ export declare class GlobalPlug implements Plug {
     anonymize(): void;
     setToken(token: string): void;
     unsetToken(): void;
-    track<T extends ExternalEventType>(type: T, payload: ExternalEventPayload<T>): Promise<ExternalEvent<T>>;
+    track<T extends ExternalTrackingEventType>(type: T, payload: ExternalTrackingEventPayload<T>): Promise<ExternalTrackingEvent<T>>;
     evaluate<T extends JsonValue>(query: string, options?: EvaluationOptions): Promise<T>;
     test(expression: string, options?: EvaluationOptions): Promise<boolean>;
-    fetch<C extends JsonObject, I extends VersionedSlotId = VersionedSlotId>(slotId: I, options?: FetchOptions): Promise<FetchResponse<I, C>>;
+    fetch<I extends VersionedSlotId>(slotId: I, options?: FetchOptions<SlotContent<I>>): Promise<FetchResponse<I>>;
+    fetch<F, I extends VersionedSlotId>(slotId: I, options?: FetchOptions<SlotContent<I> | F>): Promise<FetchResponse<I, JsonObject, F>>;
     unplug(): Promise<void>;
 }
+
+export { type Configuration, type FetchOptions, type FetchResponse, GlobalPlug, type Plug, type PluginConfigurations };

package/plug.js

@@ -1,261 +1,256 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GlobalPlug = void 0;
-const sdkFacade_1 = require("@croct/sdk/facade/sdkFacade");
-const error_1 = require("@croct/sdk/error");
-const validation_1 = require("@croct/sdk/validation");
-const token_1 = require("@croct/sdk/token");
-const sdk_1 = require("@croct/sdk");
-const constants_1 = require("./constants");
-const playground_1 = require("./playground");
-const preview_1 = require("./preview");
-const PLUGIN_NAMESPACE = 'Plugin';
+import { SdkFacade } from "@croct/sdk/facade/sdkFacade";
+import { formatCause } from "@croct/sdk/error";
+import { describe } from "@croct/sdk/validation";
+import { Token } from "@croct/sdk/token";
+import { VERSION } from "@croct/sdk";
+import { loadSlotContent } from "@croct/content";
+import { CDN_URL } from "./constants.js";
+import { factory as playgroundPluginFactory } from "./playground.js";
+import { factory as previewPluginFactory } from "./preview.js";
+const PLUGIN_NAMESPACE = "Plugin";
 function detectAppId() {
-    const script = window.document.querySelector(`script[src^='${constants_1.CDN_URL}']`);
-    if (!(script instanceof HTMLScriptElement)) {
-        return null;
-    }
-    return (new URL(script.src)).searchParams.get('appId');
+  const script = window.document.querySelector(`script[src^='${CDN_URL}']`);
+  if (!(script instanceof HTMLScriptElement)) {
+    return null;
+  }
+  return new URL(script.src).searchParams.get("appId");
 }
 class GlobalPlug {
-    constructor() {
-        this.pluginFactories = {
-            playground: playground_1.factory,
-            preview: preview_1.factory,
-        };
-        this.plugins = {};
-        this.ready = new Promise(resolve => {
-            this.initialize = resolve;
-        });
-    }
-    extend(name, plugin) {
-        if (this.pluginFactories[name] !== undefined) {
-            throw new Error(`Another plugin is already registered with name "${name}".`);
-        }
-        this.pluginFactories[name] = plugin;
-    }
-    plug(configuration = {}) {
-        var _a, _b, _c;
-        if (this.instance !== undefined) {
-            const logger = this.instance.getLogger();
-            logger.info('Croct is already plugged in.');
-            return;
-        }
-        const detectedAppId = detectAppId();
-        const configuredAppId = (_a = configuration.appId) !== null && _a !== void 0 ? _a : null;
-        if (detectedAppId !== null && configuredAppId !== null && detectedAppId !== configuredAppId) {
-            throw new Error('The specified app ID and the auto-detected app ID are conflicting. '
-                + 'There is no need to specify an app ID when using an application-specific tag. '
-                + 'Please try again omitting the "appId" option. '
-                + 'For help, see https://croct.help/sdk/javascript/conflicting-app-id');
-        }
-        const appId = detectedAppId !== null && detectedAppId !== void 0 ? detectedAppId : configuredAppId;
-        if (appId === null) {
-            throw new Error('The app ID must be specified when it cannot be auto-detected. '
-                + 'Please try again specifying the "appId" option.'
-                + 'For help, see https://croct.help/sdk/javascript/missing-app-id');
-        }
-        const { plugins, test, ...sdkConfiguration } = configuration;
-        const sdk = sdkFacade_1.SdkFacade.init({
-            ...sdkConfiguration,
-            appId: appId,
-            test: test !== null && test !== void 0 ? test : (typeof process === 'object' && (((_b = process.env) === null || _b === void 0 ? void 0 : _b.CROCT_TEST_MODE) !== undefined
-                ? process.env.CROCT_TEST_MODE === 'true'
-                : ((_c = process.env) === null || _c === void 0 ? void 0 : _c.NODE_ENV) === 'test')),
-        });
-        this.instance = sdk;
-        const logger = this.instance.getLogger();
-        if (detectedAppId === configuredAppId) {
-            logger.warn('It is strongly recommended omitting the "appId" option when using '
-                + 'the application-specific tag as it is detected automatically.');
-        }
-        const pending = [];
-        const defaultEnabledPlugins = Object.fromEntries(Object.keys(this.pluginFactories)
-            .map(name => [name, true]));
-        for (const [name, options] of Object.entries({ ...defaultEnabledPlugins, ...plugins })) {
-            logger.debug(`Initializing plugin "${name}"...`);
-            const factory = this.pluginFactories[name];
-            if (factory === undefined) {
-                logger.error(`Plugin "${name}" is not registered.`);
-                continue;
-            }
-            if (typeof options !== 'boolean' && (options === null || typeof options !== 'object')) {
-                logger.error(`Invalid options for plugin "${name}", `
-                    + `expected either boolean or object but got ${(0, validation_1.describe)(options)}`);
-                continue;
-            }
-            if (options === false) {
-                logger.warn(`Plugin "${name}" is declared but not enabled`);
-                continue;
-            }
-            const args = {
-                options: options === true ? {} : options,
-                sdk: {
-                    version: sdk_1.VERSION,
-                    appId: appId,
-                    tracker: sdk.tracker,
-                    evaluator: sdk.evaluator,
-                    user: sdk.user,
-                    session: sdk.session,
-                    tab: sdk.context.getTab(),
-                    userTokenStore: {
-                        getToken: sdk.getToken.bind(sdk),
-                        setToken: sdk.setToken.bind(sdk),
-                    },
-                    previewTokenStore: sdk.previewTokenStore,
-                    cidAssigner: sdk.cidAssigner,
-                    eventManager: sdk.eventManager,
-                    getLogger: (...namespace) => sdk.getLogger(PLUGIN_NAMESPACE, name, ...namespace),
-                    getTabStorage: (...namespace) => (sdk.getTabStorage(PLUGIN_NAMESPACE, name, ...namespace)),
-                    getBrowserStorage: (...namespace) => (sdk.getBrowserStorage(PLUGIN_NAMESPACE, name, ...namespace)),
-                },
-            };
-            let plugin;
-            try {
-                plugin = factory(args);
-            }
-            catch (error) {
-                logger.error(`Failed to initialize plugin "${name}": ${(0, error_1.formatCause)(error)}`);
-                continue;
-            }
-            logger.debug(`Plugin "${name}" initialized`);
-            if (typeof plugin !== 'object') {
-                continue;
-            }
-            this.plugins[name] = plugin;
-            const promise = plugin.enable();
-            if (!(promise instanceof Promise)) {
-                logger.debug(`Plugin "${name}" enabled`);
-                continue;
-            }
-            pending.push(promise.then(() => logger.debug(`Plugin "${name}" enabled`))
-                .catch(error => logger.error(`Failed to enable plugin "${name}": ${(0, error_1.formatCause)(error)}`)));
-        }
-        Promise.all(pending)
-            .then(() => {
-            this.initialize();
-            logger.debug('Initialization complete');
-        });
-    }
-    get initialized() {
-        return this.instance !== undefined;
-    }
-    get plugged() {
-        return this.ready.then(() => this);
+  constructor() {
+    this.pluginFactories = {
+      playground: playgroundPluginFactory,
+      preview: previewPluginFactory
+    };
+    this.plugins = {};
+    this.ready = new Promise((resolve) => {
+      this.initialize = resolve;
+    });
+  }
+  extend(name, plugin) {
+    if (this.pluginFactories[name] !== void 0) {
+      throw new Error(`Another plugin is already registered with name "${name}".`);
     }
-    get flushed() {
-        return this.tracker
-            .flushed
-            .then(() => this);
+    this.pluginFactories[name] = plugin;
+  }
+  plug(configuration = {}) {
+    if (this.instance !== void 0) {
+      const logger2 = this.instance.getLogger();
+      logger2.info("Croct is already plugged in.");
+      return;
     }
-    get sdk() {
-        if (this.instance === undefined) {
-            throw new Error('Croct is not plugged in. For help, see https://croct.help/sdk/javascript/not-plugged-in');
-        }
-        return this.instance;
-    }
-    get tracker() {
-        return this.sdk.tracker;
-    }
-    get evaluator() {
-        return this.sdk.evaluator;
+    const detectedAppId = detectAppId();
+    const configuredAppId = configuration.appId ?? null;
+    if (detectedAppId !== null && configuredAppId !== null && detectedAppId !== configuredAppId) {
+      throw new Error(
+        'The specified app ID and the auto-detected app ID are conflicting. There is no need to specify an app ID when using an application-specific tag. Please try again omitting the "appId" option. For help, see https://croct.help/sdk/javascript/conflicting-app-id'
+      );
     }
-    get user() {
-        return this.sdk.user;
+    const appId = detectedAppId ?? configuredAppId;
+    if (appId === null) {
+      throw new Error(
+        'The app ID must be specified when it cannot be auto-detected. Please try again specifying the "appId" option.For help, see https://croct.help/sdk/javascript/missing-app-id'
+      );
     }
-    get session() {
-        return this.sdk.session;
+    const { plugins, test, ...sdkConfiguration } = configuration;
+    if (sdkConfiguration.defaultPreferredLocale === "") {
+      delete sdkConfiguration.defaultPreferredLocale;
     }
-    isAnonymous() {
-        return this.sdk
-            .context
-            .isAnonymous();
+    const sdk = SdkFacade.init({
+      ...sdkConfiguration,
+      appId,
+      test: test ?? (typeof process === "object" && (process.env?.CROCT_TEST_MODE !== void 0 ? process.env.CROCT_TEST_MODE === "true" : process.env?.NODE_ENV === "test"))
+    });
+    this.instance = sdk;
+    const logger = this.instance.getLogger();
+    if (detectedAppId === configuredAppId) {
+      logger.warn(
+        'It is strongly recommended omitting the "appId" option when using the application-specific tag as it is detected automatically.'
+      );
     }
-    getUserId() {
-        return this.sdk
-            .context
-            .getUser();
-    }
-    identify(userId) {
-        if (typeof userId !== 'string') {
-            throw new Error('The user ID must be a string. For help, see https://croct.help/sdk/javascript/invalid-user-id');
+    const pending = [];
+    const defaultEnabledPlugins = Object.fromEntries(
+      Object.keys(this.pluginFactories).map((name) => [name, true])
+    );
+    for (const [name, options] of Object.entries({ ...defaultEnabledPlugins, ...plugins })) {
+      logger.debug(`Initializing plugin "${name}"...`);
+      const factory = this.pluginFactories[name];
+      if (factory === void 0) {
+        logger.error(`Plugin "${name}" is not registered.`);
+        continue;
+      }
+      if (typeof options !== "boolean" && (options === null || typeof options !== "object")) {
+        logger.error(
+          `Invalid options for plugin "${name}", expected either boolean or object but got ${describe(options)}`
+        );
+        continue;
+      }
+      if (options === false) {
+        logger.warn(`Plugin "${name}" is declared but not enabled`);
+        continue;
+      }
+      const args = {
+        options: options === true ? {} : options,
+        sdk: {
+          version: VERSION,
+          appId,
+          tracker: sdk.tracker,
+          evaluator: sdk.evaluator,
+          user: sdk.user,
+          session: sdk.session,
+          tab: sdk.context.getTab(),
+          userTokenStore: {
+            getToken: sdk.getToken.bind(sdk),
+            setToken: sdk.setToken.bind(sdk)
+          },
+          previewTokenStore: sdk.previewTokenStore,
+          cidAssigner: sdk.cidAssigner,
+          eventManager: sdk.eventManager,
+          getLogger: (...namespace) => sdk.getLogger(PLUGIN_NAMESPACE, name, ...namespace),
+          getTabStorage: (...namespace) => sdk.getTabStorage(PLUGIN_NAMESPACE, name, ...namespace),
+          getBrowserStorage: (...namespace) => sdk.getBrowserStorage(PLUGIN_NAMESPACE, name, ...namespace)
         }
-        this.sdk.identify(userId);
-    }
-    anonymize() {
-        this.sdk.anonymize();
-    }
-    setToken(token) {
-        this.sdk.setToken(token_1.Token.parse(token));
+      };
+      let plugin;
+      try {
+        plugin = factory(args);
+      } catch (error) {
+        logger.error(`Failed to initialize plugin "${name}": ${formatCause(error)}`);
+        continue;
+      }
+      logger.debug(`Plugin "${name}" initialized`);
+      if (typeof plugin !== "object") {
+        continue;
+      }
+      this.plugins[name] = plugin;
+      const promise = plugin.enable();
+      if (!(promise instanceof Promise)) {
+        logger.debug(`Plugin "${name}" enabled`);
+        continue;
+      }
+      pending.push(
+        promise.then(() => logger.debug(`Plugin "${name}" enabled`)).catch((error) => logger.error(`Failed to enable plugin "${name}": ${formatCause(error)}`))
+      );
     }
-    unsetToken() {
-        this.sdk.unsetToken();
+    Promise.all(pending).then(() => {
+      this.initialize();
+      logger.debug("Initialization complete");
+    });
+  }
+  get initialized() {
+    return this.instance !== void 0;
+  }
+  get plugged() {
+    return this.ready.then(() => this);
+  }
+  get flushed() {
+    return this.tracker.flushed.then(() => this);
+  }
+  get sdk() {
+    if (this.instance === void 0) {
+      throw new Error("Croct is not plugged in. For help, see https://croct.help/sdk/javascript/not-plugged-in");
     }
-    track(type, payload) {
-        return this.sdk
-            .tracker
-            .track(type, payload);
+    return this.instance;
+  }
+  get tracker() {
+    return this.sdk.tracker;
+  }
+  get evaluator() {
+    return this.sdk.evaluator;
+  }
+  get user() {
+    return this.sdk.user;
+  }
+  get session() {
+    return this.sdk.session;
+  }
+  isAnonymous() {
+    return this.sdk.context.isAnonymous();
+  }
+  getUserId() {
+    return this.sdk.context.getUser();
+  }
+  identify(userId) {
+    if (typeof userId !== "string") {
+      throw new Error(
+        "The user ID must be a string. For help, see https://croct.help/sdk/javascript/invalid-user-id"
+      );
     }
-    evaluate(query, options = {}) {
-        return this.sdk
-            .evaluator
-            .evaluate(query, options)
-            .catch(error => {
-            const logger = this.sdk.getLogger();
-            const reference = query.length > 20 ? `${query.slice(0, 20)}...` : query;
-            logger.error(`Failed to evaluate query "${reference}": ${(0, error_1.formatCause)(error)}`);
-            throw error;
-        });
+    this.sdk.identify(userId);
+  }
+  anonymize() {
+    this.sdk.anonymize();
+  }
+  setToken(token) {
+    this.sdk.setToken(Token.parse(token));
+  }
+  unsetToken() {
+    this.sdk.unsetToken();
+  }
+  track(type, payload) {
+    return this.sdk.tracker.track(type, payload);
+  }
+  evaluate(query, options = {}) {
+    return this.sdk.evaluator.evaluate(query, options).catch((error) => {
+      const logger = this.sdk.getLogger();
+      const reference = query.length > 20 ? `${query.slice(0, 20)}...` : query;
+      logger.error(`Failed to evaluate query "${reference}": ${formatCause(error)}`);
+      throw error;
+    });
+  }
+  test(expression, options = {}) {
+    return this.evaluate(expression, options).then((result) => result === true);
+  }
+  fetch(slotId, { fallback, ...options } = {}) {
+    const [id, version = "latest"] = slotId.split("@");
+    const logger = this.sdk.getLogger();
+    const preferredLocale = options.preferredLocale !== void 0 && options.preferredLocale !== "" ? options.preferredLocale : void 0;
+    return this.sdk.contentFetcher.fetch(id, {
+      ...options,
+      preferredLocale,
+      version: version === "latest" ? void 0 : version
+    }).catch(async (error) => {
+      logger.error(`Failed to fetch content for slot "${id}@${version}": ${formatCause(error)}`);
+      const resolvedFallback = fallback === void 0 ? await loadSlotContent(slotId, preferredLocale) ?? void 0 : fallback;
+      if (resolvedFallback === void 0) {
+        throw error;
+      }
+      return { content: resolvedFallback };
+    });
+  }
+  async unplug() {
+    if (this.instance === void 0) {
+      return;
     }
-    test(expression, options = {}) {
-        return this.evaluate(expression, options)
-            .then(result => result === true);
+    const { instance, plugins } = this;
+    const logger = this.sdk.getLogger();
+    const pending = [];
+    for (const [pluginName, controller] of Object.entries(plugins)) {
+      if (typeof controller.disable !== "function") {
+        continue;
+      }
+      logger.debug(`Disabling plugin "${pluginName}"...`);
+      const promise = controller.disable();
+      if (!(promise instanceof Promise)) {
+        logger.debug(`Plugin "${pluginName}" disabled`);
+        continue;
+      }
+      pending.push(
+        promise.then(() => logger.debug(`Plugin "${pluginName}" disabled`)).catch((error) => logger.error(`Failed to disable "${pluginName}": ${formatCause(error)}`))
+      );
     }
-    fetch(slotId, options = {}) {
-        const [id, version = 'latest'] = slotId.split('@');
-        const logger = this.sdk.getLogger();
-        return this.sdk
-            .contentFetcher
-            .fetch(id, version === 'latest' ? options : { ...options, version: version })
-            .catch(error => {
-            logger.error(`Failed to fetch content for slot "${id}@${version}": ${(0, error_1.formatCause)(error)}`);
-            throw error;
-        });
-    }
-    async unplug() {
-        if (this.instance === undefined) {
-            return;
-        }
-        const { instance, plugins } = this;
-        const logger = this.sdk.getLogger();
-        const pending = [];
-        for (const [pluginName, controller] of Object.entries(plugins)) {
-            if (typeof controller.disable !== 'function') {
-                continue;
-            }
-            logger.debug(`Disabling plugin "${pluginName}"...`);
-            const promise = controller.disable();
-            if (!(promise instanceof Promise)) {
-                logger.debug(`Plugin "${pluginName}" disabled`);
-                continue;
-            }
-            pending.push(promise.then(() => logger.debug(`Plugin "${pluginName}" disabled`))
-                .catch(error => logger.error(`Failed to disable "${pluginName}": ${(0, error_1.formatCause)(error)}`)));
-        }
-        // Reset
-        delete this.instance;
-        this.plugins = {};
-        this.ready = new Promise(resolve => {
-            this.initialize = resolve;
-        });
-        await Promise.all(pending);
-        try {
-            await instance.close();
-        }
-        finally {
-            logger.info('🔌 Croct has been unplugged.');
-        }
+    delete this.instance;
+    this.plugins = {};
+    this.ready = new Promise((resolve) => {
+      this.initialize = resolve;
+    });
+    await Promise.all(pending);
+    try {
+      await instance.close();
+    } finally {
+      logger.info("\u{1F50C} Croct has been unplugged.");
     }
+  }
 }
-exports.GlobalPlug = GlobalPlug;
-//# sourceMappingURL=plug.js.map
+export {
+  GlobalPlug
+};

package/plugin.cjs

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var plugin_exports = {};
+module.exports = __toCommonJS(plugin_exports);

package/plugin.d.cts

@@ -0,0 +1,41 @@
+import { TokenStore } from '@croct/sdk/token';
+import { EvaluatorFacade } from '@croct/sdk/facade/evaluatorFacade';
+import { TrackerFacade } from '@croct/sdk/facade/trackerFacade';
+import { SdkEventManager } from './sdk/index.cjs';
+import { UserFacade } from '@croct/sdk/facade/userFacade';
+import { SessionFacade } from '@croct/sdk/facade/sessionFacade';
+import { Tab } from '@croct/sdk/tab';
+import { CidAssigner } from '@croct/sdk/cid';
+import { Logger } from '@croct/sdk/logging';
+import '@croct/sdk/eventManager';
+import '@croct/sdk/sdkEvents';
+
+interface PluginSdk {
+    readonly version: string;
+    readonly appId: string;
+    readonly tracker: TrackerFacade;
+    readonly evaluator: EvaluatorFacade;
+    readonly user: UserFacade;
+    readonly session: SessionFacade;
+    readonly tab: Tab;
+    readonly userTokenStore: TokenStore;
+    readonly previewTokenStore: TokenStore;
+    readonly cidAssigner: CidAssigner;
+    readonly eventManager: SdkEventManager;
+    getLogger(...namespace: string[]): Logger;
+    getTabStorage(...namespace: string[]): Storage;
+    getBrowserStorage(...namespace: string[]): Storage;
+}
+interface PluginArguments<T = any> {
+    options: T;
+    sdk: PluginSdk;
+}
+interface PluginFactory<T = any> {
+    (args: PluginArguments<T>): Plugin;
+}
+interface Plugin {
+    enable(): Promise<void> | void;
+    disable?(): Promise<void> | void;
+}
+
+export type { Plugin, PluginArguments, PluginFactory, PluginSdk };