@communecter/cocolight-api-client 1.0.21 → 1.0.23

package/src/index.js

@@ -5,6 +5,26 @@ import { createDefaultMultiServerTokenStorageStrategy } from "./utils/createDefa
 import { createDefaultTokenStorageStrategy } from "./utils/createDefaultTokenStorageStrategy.js";
 import { MultiServerTokenStorageStrategy } from "./utils/MultiServerTokenStorageStrategy.js";
 import OfflineClientManager from "./utils/OfflineClientManager.js";
+import * as reactive from "./utils/reactive.js";
 import { TokenStorageStrategy } from "./utils/TokenStorage.js";
 
-export default { ApiClient, Api, error, tokenStorageStrategy: { createDefaultTokenStorageStrategy, TokenStorageStrategy, createDefaultMultiServerTokenStorageStrategy, MultiServerTokenStorageStrategy }, OfflineClientManager };
+export default {
+  ApiClient,
+  Api,
+  error,
+
+  // Accès aux primitives réactives via .reactive
+  reactive,
+
+  // Accès direct à chaque primitive (reactive, effect, watch...) en racine
+  ...reactive,
+
+  tokenStorageStrategy: {
+    createDefaultTokenStorageStrategy,
+    TokenStorageStrategy,
+    createDefaultMultiServerTokenStorageStrategy,
+    MultiServerTokenStorageStrategy
+  },
+
+  OfflineClientManager
+};

package/src/utils/reactive.js

@@ -0,0 +1,279 @@
+// reactive.js - Système maison combinant Signal + Proxy pour réactivité profonde et fine
+
+import { ApiError } from "../error.js";
+
+const effectStack = [];
+const computedCache = new WeakMap();
+const signalRegistry = new WeakMap();
+
+/**
+ * Crée une fonction réactive qui se relance automatiquement
+ * lorsqu'une valeur réactive qu'elle utilise change.
+ * @param {Function} fn
+ * @returns {Function} le wrapper exécuté
+ */
+export function effect(fn) {
+  const wrapper = () => {
+    try {
+      effectStack.push(wrapper);
+      fn();
+    } finally {
+      effectStack.pop();
+    }
+  };
+  wrapper();
+  return wrapper;
+}
+
+/**
+ * Crée un signal observable pour une valeur primitive ou complexe.
+ * @param {*} initialValue
+ * @returns {{value: *, subscribe: Function, __isSignal: boolean}}
+ */
+function createSignal(initialValue) {
+  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;
+        subscribers.forEach(fn => fn());
+      }
+    },
+    subscribe(fn) {
+      subscribers.add(fn);
+      return () => subscribers.delete(fn);
+    },
+    __isSignal: true
+  };
+
+  return signal;
+}
+
+function isSignal(obj) {
+  return obj && obj.__isSignal === true;
+}
+
+function toRaw(obj) {
+  return isSignal(obj) ? obj.value : obj;
+}
+
+function _wrapArray(arr, path) {
+  const proxy = new Proxy(arr, {
+    get(target, prop) {
+      if (typeof prop === "string" && !isNaN(prop)) {
+        const val = target[prop];
+        return isReactive(val) ? val : reactive(val, path.concat(prop));
+      }
+      return Reflect.get(target, prop);
+    },
+    set(target, prop, value) {
+      const val = reactive(value, path.concat(prop));
+      target[prop] = val;
+      return true;
+    }
+  });
+  return proxy;
+}
+
+function _wrapReactive(obj, path = []) {
+  if (typeof obj !== "object" || obj === null) return obj;
+  if (Array.isArray(obj)) return _wrapArray(obj, path);
+  if (obj.__isReactive) return obj;
+
+  const signalMap = new Map();
+  const proxy = new Proxy(obj, {
+    // eslint-disable-next-line no-unused-vars
+    get(target, prop, receiver) {
+      if (prop === "__raw") return target;
+      if (prop === "__isReactive") return true;
+
+      if (!signalMap.has(prop)) {
+        const val = target[prop];
+        const reactiveVal = _wrapReactive(val, path.concat(prop));
+        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.concat(prop));
+      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) {
+  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) {
+  return !!obj?.__isReactive;
+}
+
+/**
+ * Crée une valeur dérivée automatiquement recalculée.
+ * @param {Function} fn
+ * @returns {{value: *}}
+ */
+export function computed(fn) {
+  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, callback) {
+  let oldValue;
+  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) {
+  if (!isReactive(obj)) return null;
+  return signalRegistry.get(obj);
+}
+
+// --- Helpers internes ---
+function _getPathValue(obj, path) {
+  return path.split(".").reduce((o, k) => (o ? o[k] : undefined), obj);
+}
+
+function _setPathValue(obj, path, value) {
+  const keys = path.split(".");
+  const lastKey = keys.pop();
+  const parent = keys.reduce((o, k) => {
+    if (o[k] == null) o[k] = {};
+    return o[k];
+  }, obj);
+  parent[lastKey] = value;
+}
+
+function _deletePathValue(obj, path) {
+  const keys = path.split(".");
+  const lastKey = keys.pop();
+  const parent = keys.reduce((o, k) => o?.[k], obj);
+  if (parent && lastKey in parent) delete parent[lastKey];
+}
+
+function _applyTransformIfExists(path, val, entity) {
+  const topKey = path.split(".")[0];
+  const transform = entity.transforms?.[topKey];
+  return typeof transform === "function" ? transform(val, entity.serverData) : val;
+}
+
+/**
+ * Synchronise certaines clés du draft avec serverData tant qu'elles ne sont pas modifiées.
+ * @param {object} entityInstance
+ * @param {string[]} keys
+ * @param {{ cleanIfEqual?: boolean }} [options]
+ */
+export function syncDraftOnServerChange(entityInstance, keys = [], { cleanIfEqual = true } = {}) {
+  for (const path of keys) {
+    effect(() => {
+      const rawServerVal = _getPathValue(entityInstance.serverData, path);
+      const transformedServerVal = _applyTransformIfExists(path, rawServerVal, entityInstance);
+
+      const draftVal = _getPathValue(entityInstance.draftData, path);
+      const initialVal = _getPathValue(entityInstance.initialDraftData, path);
+
+      const isModified = JSON.stringify(draftVal) !== JSON.stringify(initialVal);
+
+      if (!isModified) {
+        if (cleanIfEqual && JSON.stringify(draftVal) === JSON.stringify(transformedServerVal)) {
+          _deletePathValue(entityInstance.draftData, path);
+        } else {
+          _setPathValue(entityInstance.draftData, path, transformedServerVal);
+        }
+      }
+    });
+  }
+}
+
+/**
+ * Applique `syncDraftOnServerChange()` pour tous les champs autorisés de l'entité.
+ * @param {object} entityInstance
+ */
+export function autoSyncDraftFromSchema(entityInstance) {
+  const constants = Array.isArray(entityInstance.constructor.SCHEMA_CONSTANTS)
+    ? entityInstance.constructor.SCHEMA_CONSTANTS
+    : [entityInstance.constructor.SCHEMA_CONSTANTS];
+
+  const combinedSchema = { allOf: [], $defs: {} };
+
+  for (const key of constants) {
+    const sch = entityInstance.apiClient.getRequestSchema(key);
+    if (!sch) throw new ApiError(`Unable to find schema for ${key}.`);
+    if (sch.$defs) {
+      for (const [defKey, defVal] of Object.entries(sch.$defs)) {
+        if (!combinedSchema.$defs[defKey]) {
+          combinedSchema.$defs[defKey] = defVal;
+        }
+      }
+    }
+    combinedSchema.allOf.push(sch);
+  }
+
+  const data = {
+    ...entityInstance.serverData,
+    ...entityInstance.defaultFields
+  };
+
+  let allowed = entityInstance._extractWritableFields?.(combinedSchema, data) || [];
+  allowed = allowed.filter(k => !entityInstance.removeFields.includes(k));
+  allowed = allowed.filter(k => !["id"].includes(k));
+
+  syncDraftOnServerChange(entityInstance, allowed);
+}