@teardown/react-native 1.2.39 → 2.0.0

package/src/clients/logging/logging.client.ts

@@ -0,0 +1,92 @@
+export type LogLevel = "none" | "error" | "warn" | "info" | "verbose";
+
+const LOG_LEVEL_PRIORITY: Record<LogLevel, number> = {
+	none: 0,
+	error: 1,
+	warn: 2,
+	info: 3,
+	verbose: 4,
+};
+
+export type LoggingClientOptions = {
+	logLevel?: LogLevel;
+};
+
+export class LoggingClient {
+	private logLevel: LogLevel;
+
+	constructor(options?: LoggingClientOptions) {
+		this.logLevel = options?.logLevel ?? "none";
+	}
+
+	setLogLevel(level: LogLevel) {
+		this.logLevel = level;
+	}
+
+	getLogLevel(): LogLevel {
+		return this.logLevel;
+	}
+
+	shouldLog(level: LogLevel): boolean {
+		return LOG_LEVEL_PRIORITY[this.logLevel] >= LOG_LEVEL_PRIORITY[level];
+	}
+
+	createLogger(options: Omit<LoggerOptions, "loggingClient">): Logger {
+		return new Logger({
+			...options,
+			loggingClient: this,
+		});
+	}
+}
+
+/**
+ * Configuration options for logger creation
+ */
+export type LoggerOptions = {
+	/** Logger name used in log prefixes */
+	name: string;
+	/** Reference to parent LoggingClient for log level checks */
+	loggingClient: LoggingClient;
+};
+
+export class Logger {
+	/** Bound console methods to preserve call site */
+	private boundConsole = {
+		log: console.log.bind(console),
+		error: console.error.bind(console),
+		debug: console.debug.bind(console),
+		warn: console.warn.bind(console),
+		trace: console.trace.bind(console),
+	};
+
+	constructor(private readonly options: LoggerOptions) { }
+
+	get prefix() {
+		return `[Teardown:${this.options.name}]`;
+	}
+
+	info(message: string, ...args: unknown[]) {
+		if (!this.options.loggingClient.shouldLog("info")) return;
+		this.boundConsole.log(`${this.prefix} ${message}`, ...args);
+	}
+
+	error(message: string, ...args: unknown[]) {
+		if (!this.options.loggingClient.shouldLog("error")) return;
+		this.boundConsole.error(`${this.prefix} ${message}`, ...args);
+	}
+
+	debug(message: string, ...args: unknown[]) {
+		if (!this.options.loggingClient.shouldLog("verbose")) return;
+		this.boundConsole.debug(`${this.prefix} ${message}`, ...args);
+	}
+
+	warn(message: string, ...args: unknown[]) {
+		if (!this.options.loggingClient.shouldLog("warn")) return;
+		this.boundConsole.warn(`${this.prefix} ${message}`, ...args);
+	}
+
+	trace(message: string, ...args: unknown[]) {
+		if (!this.options.loggingClient.shouldLog("verbose")) return;
+		this.boundConsole.trace(`${this.prefix} ${message}`, ...args);
+	}
+}

package/src/clients/notifications/notifications.client.ts

@@ -0,0 +1,10 @@
+// import { ApiClient } from "../api/api.client";
+
+
+
+export class NotificationsClient {
+  // constructor(private readonly api: ApiClient) { }
+
+
+
+}

package/src/clients/storage/index.ts

@@ -0,0 +1 @@
+export * from "./storage.client";

package/src/clients/storage/mmkv-adapter.ts

@@ -0,0 +1,23 @@
+import type { SupportedStorageFactory } from "./storage.client";
+import * as MMKV from "react-native-mmkv";
+
+/**
+ * Creates a storage factory that uses MMKV for persistence.
+ * Each storage key gets its own MMKV instance.
+ */
+export const createMMKVStorageFactory = (): SupportedStorageFactory => {
+	return (storageKey: string) => {
+		const storage = MMKV.createMMKV({ id: storageKey });
+
+		return {
+			preload: () => {
+				storage.getAllKeys();
+			},
+			getItem: (key: string) => storage.getString(key) ?? null,
+			setItem: (key: string, value: string) => storage.set(key, value),
+			removeItem: (key: string) => storage.remove(key),
+			clear: () => storage.clearAll(),
+			keys: () => storage.getAllKeys(),
+		};
+	};
+};

package/src/clients/storage/storage.client.ts

@@ -0,0 +1,75 @@
+import type { Logger, LoggingClient } from "../logging";
+
+export type SupportedStorage = {
+  preload: () => void;
+  getItem: (key: string) => string | null;
+  setItem: (key: string, value: string) => void;
+  removeItem: (key: string) => void;
+  clear: () => void;
+  keys: () => string[];
+};
+
+export type SupportedStorageFactory = (storageKey: string) => SupportedStorage;
+
+export type StorageClientOptions = {
+  createStorage: SupportedStorageFactory;
+};
+
+export class StorageClient {
+
+  private readonly logger: Logger;
+
+  private readonly storage: Map<string, SupportedStorage> = new Map();
+
+  constructor(logging: LoggingClient, private readonly factory: SupportedStorageFactory) {
+    this.logger = logging.createLogger({
+      name: "StorageClient",
+    });
+  }
+
+  private createStorageKey(storageKey: string): string {
+    return `teardown:v1:${storageKey}`;
+  }
+
+  createStorage(storageKey: string): SupportedStorage {
+    const fullStorageKey = this.createStorageKey(storageKey);
+
+    this.logger.debug(`Creating storage for ${fullStorageKey}`);
+    if (this.storage.has(fullStorageKey)) {
+      this.logger.debug(`Storage already exists for ${fullStorageKey}`);
+      const existingStorage = this.storage.get(fullStorageKey);
+
+      if (existingStorage != null) {
+        this.logger.debug(`Returning existing storage for ${fullStorageKey}`);
+        return existingStorage;
+      }
+
+      this.logger.error(`Existing storage was found for ${fullStorageKey}, but it was null`);
+    }
+
+    this.logger.debug(`Creating new storage for ${fullStorageKey}`);
+    const newStorage = this.factory(fullStorageKey);
+    newStorage.preload();
+
+
+    const remappedStorage = {
+      ...newStorage,
+      clear: () => {
+        this.logger.debug(`Clearing storage for ${fullStorageKey}`);
+        this.storage.delete(fullStorageKey);
+      },
+    }
+
+    this.storage.set(fullStorageKey, remappedStorage);
+    this.logger.info(`Storage created for ${fullStorageKey}`);
+
+    return remappedStorage;
+  }
+
+  shutdown(): void {
+    this.storage.forEach((storage) => {
+      storage.clear();
+    });
+    this.storage.clear();
+  }
+}

package/src/clients/utils/index.ts

@@ -0,0 +1 @@
+export * from "./utils.client";

package/src/clients/utils/utils.client.ts

@@ -0,0 +1,75 @@
+import type { Logger, LoggingClient } from "../logging";
+import { v4 as uuidv4 } from "uuid";
+
+export class UtilsClient {
+	private readonly logger: Logger;
+
+	constructor(logging: LoggingClient) {
+		this.logger = logging.createLogger({
+			name: "UtilsClient",
+		});
+	}
+
+	async generateRandomUUID(): Promise<string> {
+		this.logger.debug("Generating random UUID");
+		const uuid = uuidv4();
+		this.logger.debug(`Random UUID generated: ${uuid}`);
+		return uuid;
+		// this.logger.debug("Generating random UUID");
+		// // Generate a random UUID v4 (xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx)
+		// // Uses only Math.random and string manipulation, no dependencies.
+		// const hex: string[] = [];
+		// for (let i = 0; i < 256; ++i) {
+		// 	hex.push((i < 16 ? "0" : "") + i.toString(16));
+		// }
+
+		// // Seeded random number generator using mulberry32
+		// let seedValue = 0;
+		// if (seed) {
+		// 	// Simple hash function to convert seed string to number
+		// 	for (let i = 0; i < seed.length; i++) {
+		// 		seedValue = ((seedValue << 5) - seedValue + seed.charCodeAt(i)) | 0;
+		// 	}
+		// 	seedValue = Math.abs(seedValue);
+		// }
+
+		// const seededRandom = (): number => {
+		// 	seedValue = (seedValue + 0x6d2b79f5) | 0;
+		// 	let t = Math.imul(seedValue ^ (seedValue >>> 15), 1 | seedValue);
+		// 	t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+		// 	return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+		// };
+
+		// const getRandomByte = (): number => Math.floor((seed ? seededRandom() : Math.random()) * 256);
+		// const rnds = new Array(16).fill(0).map(getRandomByte);
+
+		// // Per spec:
+		// rnds[6] = (rnds[6]! & 0x0f) | 0x40; // version 4
+		// rnds[8] = (rnds[8]! & 0x3f) | 0x80; // variant 10
+
+		// const uuid =
+		// 	hex[rnds[0]!]! +
+		// 	hex[rnds[1]!]! +
+		// 	hex[rnds[2]!]! +
+		// 	hex[rnds[3]!]! +
+		// 	"-" +
+		// 	hex[rnds[4]!]! +
+		// 	hex[rnds[5]!]! +
+		// 	"-" +
+		// 	hex[rnds[6]!]! +
+		// 	hex[rnds[7]!]! +
+		// 	"-" +
+		// 	hex[rnds[8]!]! +
+		// 	hex[rnds[9]!]! +
+		// 	"-" +
+		// 	hex[rnds[10]!]! +
+		// 	hex[rnds[11]!]! +
+		// 	hex[rnds[12]!]! +
+		// 	hex[rnds[13]!]! +
+		// 	hex[rnds[14]!]! +
+		// 	hex[rnds[15]!]!;
+
+		// this.logger.debug(`Random UUID generated: ${uuid}`);
+		// return uuid;
+	}
+}

package/src/contexts/index.ts

@@ -0,0 +1 @@
+export * from "./teardown.context";

package/src/contexts/teardown.context.ts

@@ -0,0 +1,17 @@
+import { createContext, useContext } from "react";
+
+import type { TeardownCore } from "../teardown.core";
+
+export type TeardownContextType = {
+	core: TeardownCore;
+};
+
+export const TeardownContext = createContext<TeardownContextType | null>(null);
+
+export const useTeardown = () => {
+	const context = useContext(TeardownContext);
+	if (!context) {
+		throw new Error("useTeardown must be used within a TeardownProvider");
+	}
+	return context;
+};

package/src/exports/expo.ts

@@ -0,0 +1 @@
+export * from "../clients/device/expo-adapter";

package/src/exports/index.ts

@@ -0,0 +1,16 @@
+export * from "../teardown.core";
+
+
+// Providers
+export * from "../providers/teardown.provider";
+
+// Clients
+export * from "../clients/api";
+export * from "../clients/logging";
+export * from "../clients/utils";
+export * from "../clients/storage";
+export * from "../clients/device/device.client";
+
+// Hooks
+export * from "../hooks/use-force-update";
+export * from "../hooks/use-session";

package/src/exports/mmkv.ts

@@ -0,0 +1 @@
+export * from "../clients/storage/mmkv-adapter";

package/src/hooks/use-force-update.ts

@@ -0,0 +1,38 @@
+import { useEffect, useState } from "react";
+import type { VersionStatus } from "../clients/force-update";
+import { useTeardown } from "../contexts/teardown.context";
+
+export type UseForceUpdateResult = {
+  /**
+   * The current version status.
+   */
+  versionStatus: VersionStatus;
+  /**
+   * Whether an update is available for this version, but is not required.
+   */
+  isUpdateAvailable: boolean;
+  /**
+   * Whether the the current version is out of date and is forced to be updated. "force_update" - isUpdateAvailable will also be true if this is true.
+   */
+  isUpdateRequired: boolean;
+};
+
+export const useForceUpdate = (): UseForceUpdateResult => {
+  const { core } = useTeardown();
+
+  const [versionStatus, setVersionStatus] = useState<VersionStatus>(
+    core.forceUpdate.getVersionStatus()
+  );
+
+  useEffect(() => {
+    const unsubscribe = core.forceUpdate.onVersionStatusChange(setVersionStatus);
+    return unsubscribe;
+  }, [core.forceUpdate]);
+
+  return {
+    versionStatus,
+    isUpdateRequired: versionStatus.type === "update_required",
+    isUpdateAvailable: versionStatus.type === "update_available" || versionStatus.type === "update_required" || versionStatus.type === "update_recommended",
+  };
+};
+

package/src/hooks/use-session.ts

@@ -0,0 +1,26 @@
+import { useEffect, useState } from "react";
+import type { Session } from "../clients/identity/identity.client";
+import { useTeardown } from "../contexts/teardown.context";
+
+export type UseSessionResult = Session | null
+
+export const useSession = (): UseSessionResult => {
+  const { core } = useTeardown();
+
+  const [session, setSession] = useState<Session | null>(
+    core.identity.getSessionState()
+  );
+
+  useEffect(() => {
+    const unsubscribe = core.identity.onIdentifyStateChange((state) => {
+      if (state.type === "identified") {
+        setSession(state.session);
+      } else {
+        setSession(null);
+      }
+    });
+    return unsubscribe;
+  }, [core.identity]);
+
+  return session;
+};

package/src/providers/teardown.provider.tsx

@@ -0,0 +1,28 @@
+import { memo, useEffect, useMemo } from "react";
+
+import type { TeardownCore } from "../teardown.core";
+import { TeardownContext } from "../contexts/teardown.context";
+
+export { useTeardown } from "../contexts/teardown.context";
+
+export type TeardownProviderProps = {
+	children: React.ReactNode;
+	core: TeardownCore;
+};
+
+export const TeardownProvider = memo((props: TeardownProviderProps) => {
+	const { children, core } = props;
+	const context = useMemo(() => ({ core }), [core]);
+
+	useEffect(() => {
+		return () => {
+			core.shutdown();
+		};
+	}, [core]);
+
+	return (
+		<TeardownContext.Provider value={context}>
+			{children}
+		</TeardownContext.Provider>
+	);
+});

package/src/teardown.core.ts

@@ -0,0 +1,76 @@
+import { ApiClient } from "./clients/api";
+import { DeviceClient, type DeviceClientOptions } from "./clients/device/device.client";
+import { ForceUpdateClient, type ForceUpdateClientOptions } from "./clients/force-update";
+import { IdentityClient } from "./clients/identity";
+import { type LogLevel, LoggingClient, type Logger } from "./clients/logging";
+import { StorageClient, type SupportedStorageFactory } from "./clients/storage";
+import { UtilsClient } from "./clients/utils/utils.client";
+
+export type TeardownCoreOptions = {
+	org_id: string;
+	project_id: string;
+	api_key: string;
+	// environment_slug: string; // TODO: add this back in
+	storageFactory: SupportedStorageFactory;
+	deviceAdapter: DeviceClientOptions["adapter"];
+	forceUpdate?: ForceUpdateClientOptions;
+};
+
+export class TeardownCore {
+	private readonly logging: LoggingClient;
+	private readonly logger: Logger;
+	private readonly utils: UtilsClient;
+	public readonly api: ApiClient;
+	private readonly storage: StorageClient;
+	public readonly device: DeviceClient;
+	public readonly identity: IdentityClient;
+	public readonly forceUpdate: ForceUpdateClient;
+
+	constructor(private readonly options: TeardownCoreOptions) {
+		this.options = options;
+
+		this.logging = new LoggingClient();
+		// this.setLogLevel("verbose");
+
+		this.logger = this.logging.createLogger({
+			name: "TeardownCore",
+		});
+		this.utils = new UtilsClient(this.logging);
+		this.storage = new StorageClient(this.logging, this.options.storageFactory);
+		this.api = new ApiClient(this.logging, this.storage, {
+			org_id: this.options.org_id,
+			project_id: this.options.project_id,
+			api_key: this.options.api_key,
+			environment_slug: "production",
+		});
+		this.device = new DeviceClient(this.logging, this.utils, this.storage, {
+			adapter: this.options.deviceAdapter,
+		});
+		this.identity = new IdentityClient(
+			this.logging,
+			this.utils,
+			this.storage,
+			this.api,
+			this.device
+		);
+		this.forceUpdate = new ForceUpdateClient(this.logging, this.storage, this.identity, this.options.forceUpdate)
+
+		void this.initialize().catch((error) => {
+			this.logger.error("Error initializing TeardownCore", { error });
+		});
+
+	}
+
+	async initialize(): Promise<void> {
+		await this.identity.initialize();
+	}
+
+	setLogLevel(level: LogLevel): void {
+		this.logging.setLogLevel(level);
+	}
+
+	shutdown(): void {
+		this.logger.info("Shutting down TeardownCore");
+		this.storage.shutdown();
+	}
+}

package/dist/components/index.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/components/index.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=index.js.map

package/dist/components/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/components/index.ts"],"names":[],"mappings":""}

package/dist/components/teardown-logo.d.ts

@@ -1,4 +0,0 @@
-import type { FunctionComponent } from "react";
-import { type SvgProps } from "react-native-svg";
-export type TeardownLogoProps = SvgProps;
-export declare const TeardownLogo: FunctionComponent<TeardownLogoProps>;

package/dist/components/teardown-logo.js

@@ -1,35 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TeardownLogo = void 0;
-const react_native_svg_1 = __importStar(require("react-native-svg"));
-const TeardownLogo = (props) => {
-    const {} = props;
-    return (<react_native_svg_1.default width="350" height="350" viewBox="0 0 350 350" fill="none" {...props}>
-			<react_native_svg_1.Path fillRule="evenodd" clipRule="evenodd" d="M175.09 345L300 218.574L256.859 174.909L299.821 131.426L174.91 5.00001L50 131.426L93.141 175.091L50.179 218.574L175.09 345ZM114.879 197.093L93.656 218.574L175.09 300.995L256.523 218.574L235.12 196.911L174.91 257.853L114.879 197.093ZM213.382 174.909L174.91 213.848L136.618 175.091L175.09 136.152L213.382 174.909ZM235.12 152.907L175.09 92.147L114.879 153.089L93.477 131.426L174.91 49.005L256.344 131.426L235.12 152.907Z" fill="white"/>
-		</react_native_svg_1.default>);
-};
-exports.TeardownLogo = TeardownLogo;
-//# sourceMappingURL=teardown-logo.js.map

package/dist/components/teardown-logo.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"teardown-logo.js","sourceRoot":"","sources":["../../src/components/teardown-logo.tsx"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AACA,qEAA4D;AAIrD,MAAM,YAAY,GAAyC,CAAC,KAAK,EAAE,EAAE;IAC3E,MAAM,EAAE,GAAG,KAAK,CAAC;IACjB,OAAO,CACN,CAAC,0BAAG,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,CACzE;GAAA,CAAC,uBAAI,CACJ,QAAQ,CAAC,SAAS,CAClB,QAAQ,CAAC,SAAS,CAClB,CAAC,CAAC,maAAma,CACra,IAAI,CAAC,OAAO,EAEd;EAAA,EAAE,0BAAG,CAAC,CACN,CAAC;AACH,CAAC,CAAC;AAZW,QAAA,YAAY,gBAYvB"}

package/dist/containers/index.d.ts

@@ -1 +0,0 @@
-export * from './teardown.container';

package/dist/containers/index.js

@@ -1,18 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./teardown.container"), exports);
-//# sourceMappingURL=index.js.map

package/dist/containers/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/containers/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,uDAAqC"}

package/dist/containers/teardown.container.d.ts

@@ -1,8 +0,0 @@
-import type { FunctionComponent, PropsWithChildren } from "react";
-import type { PluginTuple, TeardownClient } from "../teardown.client";
-export type TeardownContainerOptions = {};
-export type TeardownContainerProps<T extends readonly PluginTuple[]> = PropsWithChildren<{
-    client: TeardownClient<T>;
-    options?: TeardownContainerOptions;
-}>;
-export declare const TeardownContainer: FunctionComponent<TeardownContainerProps<any>>;

package/dist/containers/teardown.container.js

@@ -1,26 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TeardownContainer = void 0;
-const react_1 = __importDefault(require("react"));
-const services_1 = require("../services");
-const react_native_safe_area_context_1 = require("react-native-safe-area-context");
-const react_native_gesture_handler_1 = require("react-native-gesture-handler");
-const TeardownContainer = (props) => {
-    const { children, client, options } = props;
-    const providedState = services_1.TeardownService.useProvidedState(client);
-    return (<react_native_safe_area_context_1.SafeAreaProvider>
-			<react_native_gesture_handler_1.GestureHandlerRootView>
-				{/* <BottomSheetModalProvider> TODO: Move this into a theme provider/package */}
-				{/*      <TeardownService.Provider value={providedState}>*/}
-				{children}
-				{/*        <DebuggerUi {...options?.debugger} />*/}
-				{/*      </TeardownService.Provider>*/}
-				{/* </BottomSheetModalProvider> */}
-			</react_native_gesture_handler_1.GestureHandlerRootView>
-		</react_native_safe_area_context_1.SafeAreaProvider>);
-};
-exports.TeardownContainer = TeardownContainer;
-//# sourceMappingURL=teardown.container.js.map

package/dist/containers/teardown.container.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"teardown.container.js","sourceRoot":"","sources":["../../src/containers/teardown.container.tsx"],"names":[],"mappings":";;;;;;AACA,kDAA0B;AAE1B,0CAA8C;AAC9C,mFAAkE;AAClE,+EAAsE;AAU/D,MAAM,iBAAiB,GAE1B,CAAC,KAAK,EAAE,EAAE;IACb,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,KAAK,CAAC;IAE5C,MAAM,aAAa,GAAG,0BAAe,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;IAE/D,OAAO,CACN,CAAC,iDAAgB,CAChB;GAAA,CAAC,qDAAsB,CACtB;IAAA,CAAC,8EAA8E,CAC/E;IAAA,CAAC,0DAA0D,CAC3D;IAAA,CAAC,QAAQ,CACT;IAAA,CAAC,iDAAiD,CAClD;IAAA,CAAC,qCAAqC,CACtC;IAAA,CAAC,iCAAiC,CACnC;GAAA,EAAE,qDAAsB,CACzB;EAAA,EAAE,iDAAgB,CAAC,CACnB,CAAC;AACH,CAAC,CAAC;AAnBW,QAAA,iBAAiB,qBAmB5B"}

package/dist/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./containers";
-export * from "./plugins";

package/dist/index.js

@@ -1,22 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-// export * from './components';
-__exportStar(require("./containers"), exports);
-// export * from './services';
-// export * from "./teardown.client";
-__exportStar(require("./plugins"), exports);
-//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,gCAAgC;AAChC,+CAA6B;AAC7B,8BAA8B;AAC9B,qCAAqC;AACrC,4CAA0B"}