@walkeros/core 0.0.8 → 0.1.1

package/dist/index.d.mts

@@ -2,8 +2,6 @@
  * Core collector configuration interface
  */
 interface Config$4 {
-    /** Run in dry mode without executing events */
-    dryRun: boolean;
     /** Whether to run collector automatically */
     run?: boolean;
     /** Initial consent state */
@@ -18,6 +16,8 @@ interface Config$4 {
     globalsStatic: Properties;
     /** Static session data even on a new run */
     sessionStatic: Partial<SessionData>;
+    /** Source configurations */
+    sources?: InitSources;
     /** Destination configurations */
     destinations?: InitDestinations;
     /** Initial custom properties */
@@ -43,20 +43,14 @@ interface SessionData extends Properties {
     runs?: number;
 }
 interface Sources {
-    [id: string]: CollectorSource;
+    [id: string]: Instance;
 }
 interface Destinations$1 {
     [id: string]: Instance$1;
 }
-interface CollectorSource {
-    type: string;
-    mapping?: unknown;
-    settings?: Record<string, unknown>;
-    elb?: AnyFunction;
-}
 type CommandType = 'action' | 'config' | 'consent' | 'context' | 'destination' | 'elb' | 'globals' | 'hook' | 'init' | 'link' | 'run' | 'user' | 'walker' | string;
 interface Instance$2 {
-    push: Fn$2;
+    push: Fn$1;
     allowed: boolean;
     config: Config$4;
     consent: Consent;
@@ -76,12 +70,11 @@ interface Instance$2 {
     version: string;
 }
 
-type collector_CollectorSource = CollectorSource;
 type collector_CommandType = CommandType;
 type collector_SessionData = SessionData;
 type collector_Sources = Sources;
 declare namespace collector {
-  export type { collector_CollectorSource as CollectorSource, collector_CommandType as CommandType, Config$4 as Config, Destinations$1 as Destinations, InitConfig$1 as InitConfig, Instance$2 as Instance, collector_SessionData as SessionData, collector_Sources as Sources };
+  export type { collector_CommandType as CommandType, Config$4 as Config, Destinations$1 as Destinations, InitConfig$1 as InitConfig, Instance$2 as Instance, collector_SessionData as SessionData, collector_Sources as Sources };
 }
 
 interface Contract$1 {
@@ -141,24 +134,24 @@ interface Instance$1<Settings = unknown, Mapping = unknown> {
     queue?: Events;
     dlq?: DLQ;
     type?: string;
+    env?: Environment$1;
     init?: InitFn<Settings, Mapping>;
     push: PushFn<Settings, Mapping>;
     pushBatch?: PushBatchFn<Settings, Mapping>;
+    on?(event: Types, context?: unknown): void | Promise<void>;
 }
 interface Config$3<Settings = unknown, Mapping = unknown> {
     consent?: Consent;
     settings?: Settings;
     data?: Value | Values;
-    dryRun?: boolean;
+    env?: Environment$1;
     id?: string;
     init?: boolean;
     loadScript?: boolean;
     mapping?: Rules<Rule<Mapping>>;
-    on?: Config$2;
     policy?: Policy;
     queue?: boolean;
     verbose?: boolean;
-    wrapper?: Config;
     onError?: Error;
     onLog?: Log;
 }
@@ -166,12 +159,13 @@ type PartialConfig<Settings = unknown, Mapping = unknown> = Config$3<Partial<Set
 interface Policy {
     [key: string]: Value;
 }
-type Init$1 = Partial<Omit<Instance$1, 'push'>> & Pick<Instance$1, 'push'>;
-type InitDestination<Settings = unknown, Mapping = unknown> = Omit<Instance$1<Settings, Mapping>, 'config'> & {
-    config?: Config$3<Settings, Mapping>;
+type Init$1<Settings = unknown, Mapping = unknown> = {
+    code: Instance$1<Settings, Mapping>;
+    config?: Partial<Config$3<Settings, Mapping>>;
+    env?: Partial<Environment$1>;
 };
 interface InitDestinations {
-    [key: string]: InitDestination<any, any>;
+    [key: string]: Init$1<any, any>;
 }
 interface Destinations {
     [key: string]: Instance$1;
@@ -180,7 +174,7 @@ interface Context$1<Settings = unknown, Mapping = unknown> {
     collector: Instance$2;
     config: Config$3<Settings, Mapping>;
     data?: Data$1;
-    wrap: Wrap;
+    env: Environment$1;
 }
 interface PushContext<Settings = unknown, Mapping = unknown> extends Context$1<Settings, Mapping> {
     mapping?: Rule<Mapping>;
@@ -217,11 +211,24 @@ type Result$1 = {
     queued: Array<Ref>;
     failed: Array<Ref>;
 };
+/**
+ * Base environment requirements interface for walkerOS destinations
+ *
+ * This defines the core interface that destinations can use to declare
+ * their runtime environment requirements. Platform-specific extensions
+ * should extend this interface.
+ */
+interface Environment$1 {
+    /**
+     * Generic global properties that destinations may require
+     * Platform-specific implementations can extend this interface
+     */
+    [key: string]: unknown;
+}
 
 type destination_Batch<Mapping> = Batch<Mapping>;
 type destination_DLQ = DLQ;
 type destination_Destinations = Destinations;
-type destination_InitDestination<Settings = unknown, Mapping = unknown> = InitDestination<Settings, Mapping>;
 type destination_InitDestinations = InitDestinations;
 type destination_InitFn<Settings, Mapping> = InitFn<Settings, Mapping>;
 type destination_PartialConfig<Settings = unknown, Mapping = unknown> = PartialConfig<Settings, Mapping>;
@@ -235,7 +242,7 @@ type destination_PushEvents<Mapping = unknown> = PushEvents<Mapping>;
 type destination_PushFn<Settings, Mapping> = PushFn<Settings, Mapping>;
 type destination_Ref = Ref;
 declare namespace destination {
-  export type { destination_Batch as Batch, Config$3 as Config, Context$1 as Context, destination_DLQ as DLQ, Data$1 as Data, destination_Destinations as Destinations, Init$1 as Init, destination_InitDestination as InitDestination, destination_InitDestinations as InitDestinations, destination_InitFn as InitFn, Instance$1 as Instance, destination_PartialConfig as PartialConfig, destination_Policy as Policy, destination_Push as Push, destination_PushBatchContext as PushBatchContext, destination_PushBatchFn as PushBatchFn, destination_PushContext as PushContext, destination_PushEvent as PushEvent, destination_PushEvents as PushEvents, destination_PushFn as PushFn, destination_Ref as Ref, Result$1 as Result };
+  export type { destination_Batch as Batch, Config$3 as Config, Context$1 as Context, destination_DLQ as DLQ, Data$1 as Data, destination_Destinations as Destinations, Environment$1 as Environment, Init$1 as Init, destination_InitDestinations as InitDestinations, destination_InitFn as InitFn, Instance$1 as Instance, destination_PartialConfig as PartialConfig, destination_Policy as Policy, destination_Push as Push, destination_PushBatchContext as PushBatchContext, destination_PushBatchFn as PushBatchFn, destination_PushContext as PushContext, destination_PushEvent as PushEvent, destination_PushEvents as PushEvents, destination_PushFn as PushFn, destination_Ref as Ref, Result$1 as Result };
 }
 
 interface EventFn<R = Promise<PushResult>> {
@@ -243,7 +250,7 @@ interface EventFn<R = Promise<PushResult>> {
     (event: string): R;
     (event: string, data: Properties): R;
 }
-interface Fn$2<R = Promise<PushResult>, Config = unknown> extends EventFn<R>, WalkerCommands<R, Config> {
+interface Fn$1<R = Promise<PushResult>, Config = unknown> extends EventFn<R>, WalkerCommands<R, Config> {
 }
 interface WalkerCommands<R = Promise<PushResult>, Config = unknown> {
     (event: 'walker config', config: Partial<Config>): R;
@@ -277,7 +284,22 @@ type elb_PushResult = PushResult;
 type elb_RegisterDestination<Destination, Config> = RegisterDestination<Destination, Config>;
 type elb_WalkerCommands<R = Promise<PushResult>, Config = unknown> = WalkerCommands<R, Config>;
 declare namespace elb {
-  export type { Event$1 as Event, elb_EventFn as EventFn, Fn$2 as Fn, elb_Layer as Layer, elb_PushData as PushData, elb_PushResult as PushResult, elb_RegisterDestination as RegisterDestination, elb_WalkerCommands as WalkerCommands };
+  export type { Event$1 as Event, elb_EventFn as EventFn, Fn$1 as Fn, elb_Layer as Layer, elb_PushData as PushData, elb_PushResult as PushResult, elb_RegisterDestination as RegisterDestination, elb_WalkerCommands as WalkerCommands };
+}
+
+/**
+ * Flow configuration interface for dynamic walkerOS setup
+ * Used by bundlers and other tools to configure walkerOS dynamically
+ */
+interface Config$2 {
+    /** Collector configuration - uses existing Collector.Config from core */
+    collector: Config$4;
+    /** NPM packages required for this configuration */
+    packages: Record<string, string>;
+}
+
+declare namespace flow {
+  export type { Config$2 as Config };
 }
 
 type Error = (error: unknown, state?: unknown) => void;
@@ -330,7 +352,7 @@ type ValueType = string | ValueConfig;
 interface ValueConfig {
     condition?: Condition;
     consent?: Consent;
-    fn?: Fn$1;
+    fn?: Fn;
     key?: string;
     loop?: Loop;
     map?: Map;
@@ -339,7 +361,7 @@ interface ValueConfig {
     value?: PropertyType;
 }
 type Condition = (value: DeepPartialEvent | unknown, mapping?: Value, collector?: Instance$2) => PromiseOrValue<boolean>;
-type Fn$1 = (value: DeepPartialEvent | unknown, mapping: Value, options: Options$1) => PromiseOrValue<Property | unknown>;
+type Fn = (value: DeepPartialEvent | unknown, mapping: Value, options: Options$1) => PromiseOrValue<Property | unknown>;
 type Loop = [Value, Value];
 type Map = {
     [key: string]: Value;
@@ -353,6 +375,7 @@ type Validate = (value?: unknown) => PromiseOrValue<boolean>;
 
 type mapping_Condition = Condition;
 type mapping_Data = Data;
+type mapping_Fn = Fn;
 type mapping_Loop = Loop;
 type mapping_Map = Map;
 type mapping_Result = Result;
@@ -364,16 +387,16 @@ type mapping_ValueConfig = ValueConfig;
 type mapping_ValueType = ValueType;
 type mapping_Values = Values;
 declare namespace mapping {
-  export type { mapping_Condition as Condition, mapping_Data as Data, Fn$1 as Fn, mapping_Loop as Loop, mapping_Map as Map, Options$1 as Options, mapping_Result as Result, mapping_Rule as Rule, mapping_Rules as Rules, mapping_Validate as Validate, mapping_Value as Value, mapping_ValueConfig as ValueConfig, mapping_ValueType as ValueType, mapping_Values as Values };
+  export type { mapping_Condition as Condition, mapping_Data as Data, mapping_Fn as Fn, mapping_Loop as Loop, mapping_Map as Map, Options$1 as Options, mapping_Result as Result, mapping_Rule as Rule, mapping_Rules as Rules, mapping_Validate as Validate, mapping_Value as Value, mapping_ValueConfig as ValueConfig, mapping_ValueType as ValueType, mapping_Values as Values };
 }
 
-type Config$2 = {
+type Config$1 = {
     consent?: Array<ConsentConfig>;
     ready?: Array<ReadyConfig>;
     run?: Array<RunConfig>;
     session?: Array<SessionConfig>;
 };
-type Types = keyof Config$2;
+type Types = keyof Config$1;
 type Options = ConsentConfig | ReadyConfig | RunConfig | SessionConfig;
 interface ConsentConfig {
     [key: string]: ConsentFn;
@@ -405,7 +428,7 @@ type on_SessionConfig = SessionConfig;
 type on_SessionFn = SessionFn;
 type on_Types = Types;
 declare namespace on {
-  export type { Config$2 as Config, on_ConsentConfig as ConsentConfig, on_ConsentFn as ConsentFn, on_OnConfig as OnConfig, on_Options as Options, on_ReadyConfig as ReadyConfig, on_ReadyFn as ReadyFn, on_RunConfig as RunConfig, on_RunFn as RunFn, on_SessionConfig as SessionConfig, on_SessionFn as SessionFn, on_Types as Types };
+  export type { Config$1 as Config, on_ConsentConfig as ConsentConfig, on_ConsentFn as ConsentFn, on_OnConfig as OnConfig, on_Options as Options, on_ReadyConfig as ReadyConfig, on_ReadyFn as ReadyFn, on_RunConfig as RunConfig, on_RunFn as RunFn, on_SessionConfig as SessionConfig, on_SessionFn as SessionFn, on_Types as Types };
 }
 
 interface Context {
@@ -454,34 +477,73 @@ declare namespace schema {
   export type { schema_Contract as Contract, schema_Contracts as Contracts, Properties$1 as Properties, Property$1 as Property };
 }
 
-interface Config$1 {
-    type: string;
+interface Config {
     id?: string;
     disabled?: boolean;
     settings: AnyObject;
     onError?: AnyFunction;
 }
-type InitConfig = Partial<Config$1>;
-interface Init<T extends Config$1 = Config$1, E = AnyFunction> {
-    (collector: Instance$2, config: T): CreateSource<T, E> | Promise<CreateSource<T, E>>;
-}
-interface CreateSource<T extends Config$1 = Config$1, E = AnyFunction> {
-    source?: Instance<T>;
-    elb?: E;
+type InitConfig = Partial<Config>;
+/**
+ * Environment interface for dependency injection into sources.
+ *
+ * Sources receive all their dependencies through this environment object,
+ * making them platform-agnostic and easily testable.
+ */
+interface Environment {
+    elb: Fn$1;
+    [key: string]: unknown;
 }
-interface Instance<T extends Config$1 = Config$1> {
+/**
+ * Source instance returned by Source.Init function.
+ *
+ * Sources are stateless and contain no collector references.
+ * All communication with collector happens via env.elb function.
+ */
+interface Instance<T extends Config = Config> {
     type: string;
     config: T;
-    collector: Instance$2;
+    push: Fn$1;
     destroy?(): void | Promise<void>;
+    on?(event: Types, context?: unknown): void | Promise<void>;
+}
+/**
+ * Source initialization function signature.
+ *
+ * Sources are functions that receive configuration and environment dependencies
+ * and return a stateless instance.
+ *
+ * @param config - Source configuration (settings, type, etc.)
+ * @param env - Environment with elb function and platform APIs (defaults to {})
+ * @returns Source instance or promise of instance
+ */
+type Init<T extends Config = Config> = (config: Partial<T>, env?: Environment) => Instance<T> | Promise<Instance<T>>;
+/**
+ * Source configuration interface for collector initialization.
+ * Similar to destinations, this defines the structure for source definitions.
+ */
+type InitSource<T extends Config = Config> = {
+    code: Init<T>;
+    config?: T;
+    env?: Partial<Environment>;
+};
+/**
+ * Sources configuration for collector.
+ * Maps source IDs to their initialization configurations.
+ */
+interface InitSources {
+    [sourceId: string]: InitSource<any>;
 }
 
-type source_CreateSource<T extends Config$1 = Config$1, E = AnyFunction> = CreateSource<T, E>;
-type source_Init<T extends Config$1 = Config$1, E = AnyFunction> = Init<T, E>;
+type source_Config = Config;
+type source_Environment = Environment;
+type source_Init<T extends Config = Config> = Init<T>;
 type source_InitConfig = InitConfig;
-type source_Instance<T extends Config$1 = Config$1> = Instance<T>;
+type source_InitSource<T extends Config = Config> = InitSource<T>;
+type source_InitSources = InitSources;
+type source_Instance<T extends Config = Config> = Instance<T>;
 declare namespace source {
-  export type { Config$1 as Config, source_CreateSource as CreateSource, source_Init as Init, source_InitConfig as InitConfig, source_Instance as Instance };
+  export type { source_Config as Config, source_Environment as Environment, source_Init as Init, source_InitConfig as InitConfig, source_InitSource as InitSource, source_InitSources as InitSources, source_Instance as Instance };
 }
 
 type AnyObject<T = unknown> = Record<string, T>;
@@ -490,7 +552,7 @@ type AnyFunction = (...args: unknown[]) => unknown;
 type SingleOrArray<T> = T | Array<T>;
 declare global {
     namespace WalkerOS {
-        interface Elb extends Fn$2 {
+        interface Elb extends Fn$1 {
         }
     }
 }
@@ -498,7 +560,7 @@ type Events = Array<Event>;
 type PartialEvent = Partial<Event>;
 type DeepPartialEvent = DeepPartial<Event>;
 interface Event {
-    event: string;
+    name: string;
     data: Properties;
     context: OrderedProperties;
     globals: Properties;
@@ -566,7 +628,7 @@ interface OrderedProperties {
 }
 type Entities = Array<Entity>;
 interface Entity {
-    type: string;
+    entity: string;
     data: Properties;
     nested: Entities;
     context: OrderedProperties;
@@ -605,26 +667,6 @@ declare namespace walkeros {
   export type { walkeros_ActionHandler as ActionHandler, walkeros_AnyFunction as AnyFunction, walkeros_AnyObject as AnyObject, walkeros_Consent as Consent, walkeros_ConsentHandler as ConsentHandler, walkeros_DeepPartial as DeepPartial, walkeros_DeepPartialEvent as DeepPartialEvent, walkeros_Elb as Elb, walkeros_Entities as Entities, walkeros_Entity as Entity, walkeros_Event as Event, walkeros_Events as Events, walkeros_OrderedProperties as OrderedProperties, walkeros_PartialEvent as PartialEvent, walkeros_PromiseOrValue as PromiseOrValue, walkeros_Properties as Properties, walkeros_Property as Property, walkeros_PropertyType as PropertyType, walkeros_SingleOrArray as SingleOrArray, walkeros_Source as Source, walkeros_SourceType as SourceType, walkeros_User as User, walkeros_Version as Version };
 }
 
-interface Fn {
-    name: string;
-    type?: string;
-}
-type OnCall = (context: Fn, args: unknown[]) => void;
-interface Config {
-    dryRun?: boolean;
-    mockReturn?: unknown;
-    onCall?: OnCall;
-}
-type Wrap = <T>(name: string, originalFn: T) => T;
-
-type wrapper_Config = Config;
-type wrapper_Fn = Fn;
-type wrapper_OnCall = OnCall;
-type wrapper_Wrap = Wrap;
-declare namespace wrapper {
-  export type { wrapper_Config as Config, wrapper_Fn as Fn, wrapper_OnCall as OnCall, wrapper_Wrap as Wrap };
-}
-
 type StorageType = 'local' | 'session' | 'cookie';
 declare const Const: {
     readonly Utils: {
@@ -747,39 +789,6 @@ declare function getGrantedConsent(required: Consent | undefined, state?: Consen
  */
 declare function createDestination<Settings = unknown, Mapping = unknown>(baseDestination: Instance$1<Settings, Mapping>, config: Partial<Config$3<Settings, Mapping>>): Instance$1<Settings, Mapping>;
 
-/**
- * Creates a new source function by merging a base source with additional configuration.
- *
- * This utility enables elegant source configuration while avoiding config side-effects
- * that could occur when reusing source functions across multiple collector instances.
- *
- * @template T - The source config type extending Source.Config
- * @template E - The source elb function type
- * @param source - The base source function to extend
- * @param config - Additional configuration to merge with the source's config
- * @returns A new source function with merged configuration
- *
- * @example
- * ```typescript
- * import { createSource } from '@walkeros/core';
- * import { sourceBrowser } from '@walkeros/web-source-browser';
- *
- * const configuredSource = createSource(sourceBrowser, {
- *   settings: {
- *     scope: document.body,
- *     session: true
- *   }
- * });
- *
- * const { elb } = await createCollector({
- *   sources: {
- *     browser: configuredSource
- *   }
- * });
- * ```
- */
-declare function createSource<T extends Config$1, E = unknown>(source: Init<T, E>, config: Partial<T>): Init<T, E>;
-
 /**
  * Creates a complete event with default values.
  * Used for testing and debugging.
@@ -1110,13 +1119,4 @@ declare function validateEvent(obj: unknown, customContracts?: Contracts): Event
  */
 declare function validateProperty(obj: AnyObject, key: string, value: unknown, schema: Property$1): Property | never;
 
-/**
- * Creates a wrapper function that can be used to wrap other functions.
- *
- * @param type The type of the wrapper.
- * @param config The configuration for the wrapper.
- * @returns A wrapper function.
- */
-declare function createWrapper(type?: string, { dryRun, mockReturn, onCall }?: Config): Wrap;
-
-export { collector as Collector, Const, data as Data, destination as Destination, elb as Elb, handler as Handler, hooks as Hooks, mapping as Mapping, type MarketingParameters, on as On, request as Request, schema as Schema, type SendDataValue, type SendHeaders, type SendResponse, source as Source, type StorageType, walkeros as WalkerOS, wrapper as Wrapper, anonymizeIP, assign, castToProperty, castValue, clone, createDestination, createEvent, createSource, createWrapper, debounce, filterValues, getBrowser, getBrowserVersion, getByPath, getDeviceType, getEvent, getGrantedConsent, getHeaders, getId, getMappingEvent, getMappingValue, getMarketingParameters, getOS, getOSVersion, isArguments, isArray, isBoolean, isCommand, isDefined, isElementOrDocument, isFunction, isNumber, isObject, isPropertyType, isSameType, isString, onLog, parseUserAgent, requestToData, requestToParameter, setByPath, throttle, throwError, transformData, trim, tryCatch, tryCatchAsync, useHooks, validateEvent, validateProperty };
+export { collector as Collector, Const, data as Data, destination as Destination, elb as Elb, flow as Flow, handler as Handler, hooks as Hooks, mapping as Mapping, type MarketingParameters, on as On, request as Request, schema as Schema, type SendDataValue, type SendHeaders, type SendResponse, source as Source, type StorageType, walkeros as WalkerOS, anonymizeIP, assign, castToProperty, castValue, clone, createDestination, createEvent, debounce, filterValues, getBrowser, getBrowserVersion, getByPath, getDeviceType, getEvent, getGrantedConsent, getHeaders, getId, getMappingEvent, getMappingValue, getMarketingParameters, getOS, getOSVersion, isArguments, isArray, isBoolean, isCommand, isDefined, isElementOrDocument, isFunction, isNumber, isObject, isPropertyType, isSameType, isString, onLog, parseUserAgent, requestToData, requestToParameter, setByPath, throttle, throwError, transformData, trim, tryCatch, tryCatchAsync, useHooks, validateEvent, validateProperty };