@communecter/cocolight-api-client 1.0.155 → 1.0.157

package/src/utils/reactive.ts

@@ -1,243 +0,0 @@
-// reactive.ts - Système maison combinant Signal + Proxy pour réactivité profonde et fine
-
-const effectStack: (() => void)[] = [];
-const computedCache = new WeakMap();
-const signalRegistry = new WeakMap();
-let batchDepth = 0;
-const pendingEffects = new Set<() => void>();
-
-/**
- * Crée une fonction réactive qui se relance automatiquement
- * lorsqu'une valeur réactive qu'elle utilise change.
- */
-export function effect(fn: () => void): () => void {
-  const wrapper = () => {
-    try {
-      effectStack.push(wrapper);
-      fn();
-    } finally {
-      effectStack.pop();
-    }
-  };
-  wrapper();
-  return wrapper;
-}
-
-/**
- * Exécute une fonction dans un lot, en retardant l'exécution
- * des effets jusqu'à ce que le lot soit terminé.
- */
-export function batch(fn: () => void): void {
-  batchDepth++;
-  try {
-    fn();
-  } finally {
-    batchDepth--;
-    if (batchDepth === 0) {
-      const effects = Array.from(pendingEffects);
-      pendingEffects.clear();
-      for (const effect of effects) (effect as () => void)();
-    }
-  }
-}
-
-/**
- * Crée un signal observable pour une valeur primitive ou complexe.
- */
-function createSignal(initialValue?: any): any {
-  let value = initialValue;
-  const subscribers = new Set();
-
-  const signal = {
-    get value() {
-      const currentEffect = effectStack[effectStack.length - 1];
-      if (currentEffect) subscribers.add(currentEffect);
-      return value;
-    },
-    set value(newValue) {
-      if (value !== newValue) {
-        value = newValue;
-        if (batchDepth > 0) {
-          subscribers.forEach((fn) => pendingEffects.add(fn as () => void));
-        } else {
-          subscribers.forEach((fn) => (fn as () => void)());
-        }
-      }
-    },
-    subscribe(fn: any) {
-      subscribers.add(fn);
-      return () => subscribers.delete(fn);
-    },
-    __isSignal: true
-  };
-
-  return signal;
-}
-
-/**
- * vérifie si un objet est un signal.
- * @param {*} obj
- * @returns {boolean}
- */
-export function isSignal(obj: any) {
-  return obj && obj.__isSignal === true;
-}
-
-function toRaw(obj: any) {
-  return isSignal(obj) ? obj.value : obj;
-}
-
-function _wrapArray(arr: any[], path: string[]): any {
-  const proxy = new Proxy(arr, {
-    get(target, prop, receiver) {
-      if (typeof prop === "string" && !isNaN(+prop)) {
-        const val = target[+prop];
-        return isReactive(val) ? val : _wrapReactive(val, [...path, prop] as any);
-      }
-      return Reflect.get(target, prop, receiver);
-    },
-    set(target, prop, value) {
-      if (typeof prop === "string" && !isNaN(+prop)) {
-        const val = _wrapReactive(value, [...path, prop] as any);
-        target[+prop] = val;
-      }
-      return true;
-    }
-  });
-  return proxy;
-}
-
-function _wrapReactive(obj: any, path: any = []) {
-  if (typeof obj !== "object" || obj === null) return obj;
-  if (Array.isArray(obj)) return _wrapArray(obj, path);
-  if (obj.__isReactive) return obj;
-
-  // Ne pas proxifier les types d'upload (Buffer, File, Blob, Stream)
-  // car cela corromprait leurs données internes
-  // Buffer (Node.js)
-  if (typeof Buffer !== "undefined" && Buffer.isBuffer(obj)) return obj;
-  // File (Browser)
-  if (typeof File !== "undefined" && obj instanceof File) return obj;
-  // Blob (Browser)
-  if (typeof Blob !== "undefined" && obj instanceof Blob) return obj;
-  // ReadableStream (Node.js)
-  if (obj && typeof obj.pipe === "function" && typeof obj.on === "function") return obj;
-  // Date objects
-  if (obj instanceof Date) return obj;
-
-  // ✨ AJOUT : Ne pas proxifier les instances d'entités BaseEntity
-  if (obj.__entityTag) return obj;
-
-
-  const signalMap = new Map();
-  const proxy = new Proxy(obj, {
-
-    get(target, prop) {
-      if (prop === "__raw") return target;
-      if (prop === "__isReactive") return true;
-
-      if (!signalMap.has(prop)) {
-        const val = target[prop];
-        const reactiveVal = _wrapReactive(val, [...path, String(prop)] as any);
-        const signal = createSignal(reactiveVal);
-        signalMap.set(prop, signal);
-      }
-
-      const signal = signalMap.get(prop);
-      return signal.value;
-    },
-
-    set(target, prop, value) {
-      const val = _wrapReactive(value, [...path, String(prop)] as any);
-      if (!signalMap.has(prop)) {
-        const signal = createSignal(val);
-        signalMap.set(prop, signal);
-      }
-      signalMap.get(prop)!.value = val;
-      target[prop] = toRaw(val);
-      return true;
-    },
-
-    deleteProperty(target, prop) {
-      signalMap.delete(prop);
-      return Reflect.deleteProperty(target, prop);
-    }
-  });
-
-  signalRegistry.set(proxy, signalMap);
-  return proxy;
-}
-
-/**
- * Rend un objet profondément réactif.
- * @param {object} obj
- * @returns {object}
- */
-export function reactive(obj: any) {
-  if (typeof obj !== "object" || obj === null) return obj;
-  if (obj.__isReactive) return obj;
-  return _wrapReactive(obj);
-}
-
-/**
- * Teste si un objet est réactif.
- * @param {*} obj
- * @returns {boolean}
- */
-export function isReactive(obj: any) {
-  return obj !== null && typeof obj === "object" && obj.__isReactive === true;
-}
-
-/**
- * Crée une valeur dérivée automatiquement recalculée.
- * @param {Function} fn
- * @returns {{value: *}}
- */
-export function computed(fn: any) {
-  if (computedCache.has(fn)) return computedCache.get(fn);
-
-  const result = createSignal();
-  effect(() => result.value = fn());
-  computedCache.set(fn, result);
-  return result;
-}
-
-/**
- * Observe les changements de valeur retournée par un getter.
- * @param {Function} getter
- * @param {Function} callback
- */
-export function watch(getter: any, callback: any) {
-  let oldValue: any;
-  effect(() => {
-    const newValue = getter();
-    if (newValue !== oldValue) {
-      callback(newValue, oldValue);
-      oldValue = newValue;
-    }
-  });
-}
-
-/**
- * Récupère les signaux internes d'un objet réactif.
- * @param {object} obj
- * @returns {Map|null}
- */
-export function getSignals(obj: any) {
-  if (!isReactive(obj)) return null;
-  return signalRegistry.get(obj);
-}
-
-/**
- * Permet à React de s'abonner à une propriété réactive (champ simple).
- * @param {object} obj - Objet réactif
- * @param {string} key - Nom de la propriété à écouter
- * @param {(newValue: any, oldValue: any) => void} callback
- * @returns {() => void} fonction de nettoyage
- */
-export function subscribeTo(obj: any, key: any, callback: any) {
-  const signals = getSignals(obj);
-  if (!signals || !signals.has(key)) return () => {};
-  const signal = signals.get(key);
-  return signal?.subscribe?.(() => callback(signal.value)) ?? (() => {});
-}

package/src/utils/stream-utils.node.ts

@@ -1,12 +0,0 @@
-// utils/stream-utils.node.ts
-import type { Readable, PassThrough } from "stream";
-
-export async function bufferToReadable(buffer: Buffer): Promise<Readable> {
-  const { Readable } = await import("stream");
-  return Readable.from(buffer);
-}
-
-export async function createPassThrough(): Promise<PassThrough> {
-  const { PassThrough } = await import("stream");
-  return new PassThrough();
-}