@blac/core 2.0.0-rc-1 → 2.0.0-rc-3

package/src/BlocBase.ts

@@ -1,16 +1,14 @@
-import { Blac, BlacLifecycleEvent } from './Blac';
+import { Blac } from './Blac';
 import { BlacObservable } from './BlacObserver';
-import BlacAddon from './addons/BlacAddon';
 import { BlocConstructor } from './types';
 
 export type BlocInstanceId = string | number | undefined;
-type DependencySelector<S> = (newState: S, oldState?: S) => unknown[][];
+type DependencySelector<S> = (newState: S) => unknown[][];
 
 // Define an interface for the static properties expected on a Bloc/Cubit constructor
 interface BlocStaticProperties {
   isolated: boolean;
   keepAlive: boolean;
-  addons?: BlacAddon[];
 }
 
 /**
@@ -25,6 +23,7 @@ export abstract class BlocBase<
   S,
   P = unknown
 > {
+  public uid = crypto.randomUUID();
   /**
    * When true, every consumer will receive its own unique instance of this Bloc.
    * Use this when state should not be shared between components.
@@ -50,12 +49,6 @@ export abstract class BlocBase<
    * When provided, observers will only be notified when selected dependencies change.
    */
   defaultDependencySelector: DependencySelector<S> | undefined;
-
-  /**
-   * @internal
-   * Optional array of addons to extend the functionality of this Bloc.
-   */
-  public _addons?: BlacAddon[];
   
   /**
    * @internal
@@ -126,7 +119,7 @@ export abstract class BlocBase<
   constructor(initialState: S) {
     this._state = initialState;
     this._observer = new BlacObservable(this);
-    this._blac.dispatchEvent(BlacLifecycleEvent.BLOC_CREATED, this);
+    Blac.log('Bloc Created', this)
     this._id = this.constructor.name;
 
     // Use a type assertion for the constructor to access static properties safely
@@ -134,9 +127,6 @@ export abstract class BlocBase<
 
     this._keepAlive = constructorWithStaticProps.keepAlive;
     this._isolated = constructorWithStaticProps.isolated;
-    this._addons = constructorWithStaticProps.addons;
-
-    this._connectAddons();
   }
 
   /**
@@ -174,9 +164,11 @@ export abstract class BlocBase<
    * Notifies the Blac manager and clears all observers.
    */
   _dispose() {
-    this._observer.dispose();
-    this._blac.dispatchEvent(BlacLifecycleEvent.BLOC_DISPOSED, this);
+    this._observer.clear();
     this.onDispose?.();
+    // this._blac.dispatchEvent(BlacLifecycleEvent.BLOC_DISPOSED, this);
+    Blac.log('BlocBase._dispose', this);
+    Blac.instance.disposeBloc(this);
   }
 
   /**
@@ -199,8 +191,10 @@ export abstract class BlocBase<
    * @param consumerId The unique ID of the consumer being added
    */
   _addConsumer = (consumerId: string) => {
+    if (this._consumers.has(consumerId)) return;
     this._consumers.add(consumerId);
-    this._blac.dispatchEvent(BlacLifecycleEvent.BLOC_CONSUMER_ADDED, this, { consumerId });
+    // this._blac.dispatchEvent(BlacLifecycleEvent.BLOC_CONSUMER_ADDED, this, { consumerId });
+    Blac.log('BlocBase._addConsumer', this, consumerId);
   };
 
   /**
@@ -211,23 +205,10 @@ export abstract class BlocBase<
    * @param consumerId The unique ID of the consumer being removed
    */
   _removeConsumer = (consumerId: string) => {
-    this._blac.log(`[${this._name}:${String(this._id ?? 'default_id')}] Removing consumer: ${consumerId}`);
+    if (!this._consumers.has(consumerId)) return;
     this._consumers.delete(consumerId);
-    this._blac.dispatchEvent(BlacLifecycleEvent.BLOC_CONSUMER_REMOVED, this, { consumerId });
-  };
-
-  /**
-   * @internal
-   * Initializes all registered addons for this Bloc instance.
-   * Calls the onInit lifecycle method on each addon if defined.
-   */
-  _connectAddons = () => {
-    const { _addons: addons } = this;
-    if (addons) {
-      addons.forEach(addon => {
-        addon.onInit?.(this);
-      });
-    }
+    // this._blac.dispatchEvent(BlacLifecycleEvent.BLOC_CONSUMER_REMOVED, this, { consumerId });
+    Blac.log('BlocBase._removeConsumer', this, consumerId);
   };
 
   lastUpdate = Date.now();

package/src/index.ts

@@ -1,8 +1,7 @@
 export * from './Blac';
 export * from './BlacObserver';
+export * from './Bloc';
 export * from './BlocBase';
 export * from './Cubit';
-export * from './Bloc';
 export * from './types';
-export * from './BlacPlugin';
-export * from './addons';
+

package/src/types.ts

@@ -58,5 +58,5 @@ export type BlocConstructorParameters<B extends BlocBase<any>> =
  * @template B - The BlocGeneric type
  */
 export type BlocHookDependencyArrayFn<S> = (
-  newState: S,
+  newState: S
 ) => unknown[][];

package/src/BlacObservable.ts

@@ -1,85 +0,0 @@
-import { Blac, BlacLifecycleEvent } from './Blac';
-import { BlocBase } from './BlocBase';
-import { BlocHookDependencyArrayFn } from './types';
-
-/**
- * Represents an observer that can subscribe to state changes in a Bloc
- * @template S - The type of state being observed
- */
-export type BlacObserver<S> = {
-  /** Function to be called when state changes */
-  fn: (newState: S, oldState: S, action?: unknown) => void | Promise<void>;
-  /** Optional function to determine if the observer should be notified of state changes */
-  dependencyArray?: BlocHookDependencyArrayFn<S>;
-  /** Cached state values used for dependency comparison */
-  lastState?: unknown[][];
-  /** Unique identifier for the observer */
-  id: string;
-};
-
-/**
- * A class that manages observers for a Bloc's state changes
- * @template S - The type of state being observed
- */
-export class BlacObservable<S = unknown> {
-  /** The Bloc instance this observable is associated with */
-  bloc: BlocBase<S>;
-
-  /**
-   * Creates a new BlacObservable instance
-   * @param bloc - The Bloc instance to observe
-   */
-  constructor(bloc: BlocBase<S>) {
-    this.bloc = bloc;
-  }
-
-  private _observers = new Set<BlacObserver<S>>();
-
-  /**
-   * Gets the number of active observers
-   * @returns The number of observers currently subscribed
-   */
-  get size(): number {
-    return this._observers.size;
-  }
-
-  /**
-   * Gets the set of all observers
-   * @returns The Set of all BlacObserver instances
-   */
-  get observers() {
-    return this._observers;
-  }
-
-  /**
-   * Subscribes an observer to state changes
-   * @param observer - The observer to subscribe
-   * @returns A function that can be called to unsubscribe the observer
-   */
-  subscribe(observer: BlacObserver<S>): () => void {
-    this._observers.add(observer);
-    Blac.instance.dispatchEvent(BlacLifecycleEvent.LISTENER_ADDED, this.bloc, { listenerId: observer.id });
-    
-    // Immediately notify the new observer with the current state
-    // Pass current state as both newState and oldState for initial notification context
-    void observer.fn(this.bloc.state, this.bloc.state, { initialSubscription: true });
-
-    if (!observer.lastState) {
-      observer.lastState = observer.dependencyArray
-        ? observer.dependencyArray(this.bloc.state)
-        : [];
-    }
-    return () => {
-      this.unsubscribe(observer);
-    }
-  }
-
-  /**
-   * Unsubscribes an observer from state changes
-   * @param observer - The observer to unsubscribe
-   */
-  unsubscribe(observer: BlacObserver<S>) {
-    this._observers.delete(observer);
-    Blac.instance.dispatchEvent(BlacLifecycleEvent.LISTENER_REMOVED, this.bloc, { listenerId: observer.id });
-  }
-}

package/src/BlacPlugin.ts

@@ -1,13 +0,0 @@
-import { BlacLifecycleEvent } from './Blac';
-import { BlocBase } from './BlocBase';
-
-export interface BlacPlugin {
-  name: string;
-
-  onEvent(
-    event: BlacLifecycleEvent,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    bloc: BlocBase<any>,
-    params?: unknown,
-  ): void;
-}

package/src/addons/BlacAddon.ts

@@ -1,17 +0,0 @@
-import { BlocBase } from '../BlocBase';
-
-export type BlacAddonInit = (bloc: BlocBase<any>) => void;
-
-export type BlacAddonEmit = (params: {
-  oldState: unknown;
-  newState: unknown;
-  cubit: BlocBase<any>;
-}) => void;
-
-type BlacAddon = {
-  name: string;
-  onInit?: BlacAddonInit;
-  onEmit?: BlacAddonEmit;
-};
-
-export default BlacAddon;

package/src/addons/Persist.ts

@@ -1,105 +0,0 @@
-import { BlocBase, BlocInstanceId } from '../BlocBase';
-import BlacAddon, { BlacAddonEmit, BlacAddonInit } from './BlacAddon';
-
-type StorageType = 'localStorage' | 'sessionStorage';
-
-function getStorage(type: StorageType): Storage {
-  switch (type) {
-    case 'localStorage':
-      return localStorage;
-    case 'sessionStorage':
-      return sessionStorage;
-    default:
-      return localStorage;
-  }
-}
-
-/**
- * Persist addon
- *
- * @param options
- * @returns BlacAddon
- */
-export function Persist(
-  options: {
-    /**
-     * @default 'blac'
-     */
-    keyPrefix?: string;
-    /**
-     * @default the bloc's id
-     */
-    keyName?: string;
-    /**
-     * Used when the value is not found in storage
-     */
-    defaultValue?: unknown;
-
-    /**
-     * @default 'localStorage'
-     * @see StorageType
-     */
-    storageType?: StorageType;
-
-    /**
-     * @default false
-     */
-    onError?: (e: unknown) => void;
-  } = {},
-): BlacAddon {
-  const {
-    keyPrefix = 'blac',
-    keyName,
-    defaultValue,
-    storageType = 'localStorage',
-  } = options;
-
-  const fullKey = (id: string | BlocInstanceId) => `${keyPrefix}:${String(id)}`;
-
-  const getFromLocalStorage = (id: string | BlocInstanceId): unknown => {
-    try {
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
-      const value = getStorage(storageType).getItem(fullKey(id));
-      if (typeof value !== 'string') {
-        return defaultValue;
-      }
-
-      const p = JSON.parse(value) as { v: unknown };
-      if (typeof p.v !== 'undefined') {
-        return p.v;
-      } else {
-        return defaultValue;
-      }
-    } catch (e) {
-      options.onError?.(e);
-      return defaultValue;
-    }
-  };
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const onInit: BlacAddonInit = (e: BlocBase<any>) => {
-    const id = keyName ?? e._id;
-
-    const value = getFromLocalStorage(id);
-    e._pushState(value, null);
-  };
-
-  let currentCachedValue = '';
-  const onEmit: BlacAddonEmit = ({ newState, cubit }) => {
-    const id = keyName ?? cubit._id;
-
-    const newValue = JSON.stringify({ v: newState });
-
-    if (newValue !== currentCachedValue) {
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
-      getStorage(storageType).setItem(fullKey(id), newValue);
-      currentCachedValue = newValue;
-    }
-  };
-
-  return {
-    name: 'Persist',
-    onInit,
-    onEmit,
-  };
-}

package/src/addons/index.ts

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