@communecter/cocolight-api-client 1.0.8 → 1.0.10

package/src/mixin/DraftStateMixin.js

@@ -0,0 +1,176 @@
+// DraftStateMixin.js
+import { ApiError, ApiValidationError } from "../error.js";
+
+export const DraftStateMixin = {
+
+  /**
+   * Crée un proxy combinant draft + serveur, avec transformations facultatives.
+   * @param {Object} server
+   * @param {Object} draft
+   * @param {Array} allowedFields - champs autorisés dans le draft
+   * @param {Object} [transforms={}] - transformateurs de lecture
+   * @param {Object} [options={}] - options
+   * @returns {Proxy}
+   */
+  createDraftProxy(apiClient, server = {}, draft = {}, allowedFields = [], transforms = {}, options = {}) {
+    return new Proxy({}, {
+      get: (_, prop) => {
+        const val = prop in draft ? draft[prop] : server[prop];
+        const transformer = transforms[prop];
+        return typeof transformer === "function" ? transformer(val) : val;
+      },
+
+      set: (_, prop, value) => {
+        if (!allowedFields.includes(prop)) {
+          const message = `[DraftProxy] Le champ "${prop}" n'est pas autorisé.`;
+          if (options.throwOnError) {
+            throw new ApiValidationError(message, 400, null, {
+              field: prop,
+              value,
+              allowedFields
+            });
+          }
+          apiClient._logger.warn(message);
+          return false;
+        }
+        draft[prop] = value;
+        return true;
+      },
+
+      deleteProperty: (_, prop) => {
+        if (!allowedFields.includes(prop)) return false;
+        delete draft[prop];
+        return true;
+      },
+
+      has: (_, prop) => prop in draft || prop in server,
+      ownKeys: () => [...new Set([...Object.keys(server), ...Object.keys(draft)])],
+      getOwnPropertyDescriptor: () => ({ enumerable: true, configurable: true })
+    });
+  },
+
+  _extractWritableFields(schema = {}, data = {}, ctx = { defs: {}, visited: new Set() }) {
+    if (!schema || typeof schema !== "object") return [];
+    if (schema.$id && ctx.visited.has(schema.$id)) return [];
+    if (schema.$id) ctx.visited.add(schema.$id);
+    ctx.defs = schema.$defs || schema.definitions || ctx.defs;
+
+    const fields = [];
+
+    if (schema.$ref) {
+      const refKey = schema.$ref.replace(/^#\/?(\$defs|definitions)\//, "");
+      const resolved = ctx.defs?.[refKey];
+      if (resolved) fields.push(...this._extractWritableFields(resolved, data, ctx));
+    }
+
+    if (schema.allOf) {
+      schema.allOf.forEach(s => fields.push(...this._extractWritableFields(s, data, ctx)));
+    }
+
+    if (schema.if && schema.then) {
+      const condition = schema.if?.properties;
+      let matches = true;
+      if (condition) {
+        for (const key in condition) {
+          const expected = condition[key]?.const;
+          if (data[key] !== expected) {
+            matches = false;
+            break;
+          }
+        }
+      }
+      if (matches && schema.then) {
+        fields.push(...this._extractWritableFields(schema.then, data, ctx));
+      } else if (!matches && schema.else) {
+        fields.push(...this._extractWritableFields(schema.else, data, ctx));
+      }
+    }
+
+    if (schema.properties) {
+      fields.push(...Object.entries(schema.properties)
+        // eslint-disable-next-line no-unused-vars
+        .filter(([_, def]) => def.readOnly !== true && def.const === undefined)
+        .map(([key]) => key));
+    }
+
+    return [...new Set(fields)];
+  },
+
+  buildDraftAndProxy({ data = {}, serverData = null, constant, apiClient, transforms = {}, throwOnError = true, removeFields = [] }) {
+    const constants = Array.isArray(constant) ? constant : [constant];
+    const combinedSchema = {
+      allOf: [],
+      $defs: {}
+    };
+    
+    for (const key of constants) {
+      const sch = apiClient.getRequestSchema(key);
+      if (!sch) throw new ApiError(`Unable to find schema for ${key}.`);
+    
+      // Extraire et fusionner les $defs
+      if (sch.$defs) {
+        for (const [defKey, defVal] of Object.entries(sch.$defs)) {
+          if (combinedSchema.$defs[defKey]) {
+            apiClient._logger.warn(`Duplicate $defs key '${defKey}' from schema '${key}'`);
+          } else {
+            combinedSchema.$defs[defKey] = defVal;
+          }
+        }
+      }
+    
+      combinedSchema.allOf.push(sch);
+    }
+    const draft = {};
+    let allowed = this._extractWritableFields(combinedSchema, data);
+
+    if (data.id && allowed.indexOf("id") === -1) {
+      allowed.push("id");
+    }
+    if (data.slug && allowed.indexOf("slug") === -1) {  
+      allowed.push("slug");
+    }
+
+    allowed = allowed.filter(k => !removeFields.includes(k));
+
+    for (const key of allowed) {
+      const raw = data[key];
+      const transformed = typeof transforms[key] === "function" ? transforms[key](raw, data) : raw;
+      if (transformed !== undefined) draft[key] = transformed;
+    }
+
+    const proxy = this.createDraftProxy(apiClient, serverData, draft, allowed, transforms, { throwOnError });
+
+    return { draft, proxy };
+  },
+
+  extractChangedFieldsFromSchema(apiClient, constant, data = {}, getInitialDraft, removeFields = []) {
+    const schema = apiClient.getRequestSchema(constant);
+    let allowed = this._extractWritableFields(schema, data);
+    const changed = {};
+    const initialDraft = getInitialDraft?.() || {};
+  
+    // on enlève les champs qui ne sont pas dans le draft
+    // ou qui sont dans removeFields
+    allowed = allowed.filter(k => !removeFields.includes(k));
+
+    for (const key of allowed) {
+      // on verifie que le champ existe dans le draft
+      // sinon on ne le prend pas en compte
+
+      if (data[key] === undefined) continue;
+  
+      const current = data[key];
+      const initial = initialDraft[key];
+  
+      const changedValue =
+        JSON.stringify(current) !== JSON.stringify(initial);
+  
+      if (changedValue) {
+        changed[key] = current;
+      }
+    }
+  
+    return Object.keys(changed).length > 0 ? changed : null;
+  }
+  
+};

package/src/mixin/EntityMixin.js

@@ -0,0 +1,109 @@
+import { ApiResponseError } from "../error.js";
+
+// EntityMixin.js
+export const EntityMixin = {
+  /**
+     * Récupère le profil complet de l'organisation.
+     *
+     * @returns {Promise<Object>} Le profil complet.
+     */
+  async get() {
+    return this.apiClient.safeCall(async () => {
+      const data = await this.getPublicProfile();
+      this._setData(data);
+      return data;
+    });
+  },
+  
+  /**
+   * Mettre à jour les paramètres d'un élément : Mise à jour des paramètres spécifiques d'un élément.
+   * Constant : UPDATE_SETTINGS
+   * @param {Object} data - Les données à envoyer.
+   * @param {string} data.type - data.type
+   * @param {undefined} data.value - data.value
+   * @returns {Promise<Object>} - Les données de réponse.
+   * @throws {ApiResponseError} - En cas d'erreur détectée dans la réponse.
+   * @throws {ApiAuthenticationError} - En cas d'erreur d'authentification.
+   * @throws {Error} - En cas d'erreur inattendue.
+   */
+  async updateSettings(data = {}) {
+    data.idEntity = this.id;
+    data.typeEntity = this.getEntityType();
+    return this.callIsConnected(() => this.endpointApi.updateSettings(data));
+  },
+  
+  /**
+   * Mettre à jour la description d'un élément : Permet de mettre à jour la description courte et complète d'un élément.
+   * Constant : UPDATE_BLOCK_DESCRIPTION
+   * @param {Object} data - Les données à envoyer.
+   * @param {string} data.descMentions - Mentions dans la description (default: "")
+   * @param {string} data.shortDescription - Courte description
+   * @param {string} data.description - Description complète
+   * @returns {Promise<Object>} - Les données de réponse.
+   * @throws {ApiResponseError} - En cas d'erreur détectée dans la réponse.
+   * @throws {ApiAuthenticationError} - En cas d'erreur d'authentification.
+   * @throws {Error} - En cas d'erreur inattendue.
+   */
+  async updateDescription(data = {}) {
+    data.typeElement = this.getEntityType();
+    data.id = this.id;
+    return this.callIsConnected(() => this.endpointApi.updateBlockDescription(data));
+  },
+    
+  /**
+     * Mettre à jour les informations d'un élément : Permet de mettre à jour les informations générales d'un élément (nom, contacts, etc.).
+     * Constant : UPDATE_BLOCK_INFO
+     */
+  async updateInfo(data = {}) {
+    data.typeElement = this.getEntityType();
+    data.id = this.id;
+    return this.callIsConnected(() => this.endpointApi.updateBlockInfo(data));
+  },
+    
+  /**
+   * Mettre à jour les réseaux sociaux d'un élément : Permet de mettre à jour les liens vers les réseaux sociaux d'un élément.
+   * Constant : UPDATE_BLOCK_SOCIAL
+   */
+  async updateSocial(data = {}) {
+    data.typeElement = this.getEntityType();
+    data.id = this.id;
+    return this.callIsConnected(() => this.endpointApi.updateBlockSocial(data));
+  },
+    
+  /**
+   * Mettre à jour les localités d'un élément : Permet de mettre à jour l'adresse et les informations géographiques d'un élément.
+   * Constant : UPDATE_BLOCK_LOCALITY
+   */
+  async updateLocality(data = {}) {
+    data.typeElement = this.getEntityType();
+    data.id = this.id;
+    return this.callIsConnected(() => this.endpointApi.updateBlockLocality(data));
+  },
+    
+  /**
+   * Mettre à jour le slug d'un élément : Permet de mettre à jour le slug pour une URL simplifiée.
+   * Constant : UPDATE_BLOCK_SLUG
+   */
+  async updateSlug({ slug }) {
+    try {
+      await this.endpointApi.check({ type: this.getEntityType(), id: this.id, slug });
+    } catch (error) {
+      if(error instanceof ApiResponseError) {
+        throw new ApiResponseError("Erreur lors de la vérification du slug.", error.status, error.data);
+      }
+      throw error;
+    }
+    return this.callIsConnected(() => this.endpointApi.updateBlockSlug({ typeElement: this.getEntityType(), id: this.id, slug }));
+  },
+    
+  /**
+   * Mettre à jour l'image de profil : Permet de mettre à jour l'image de profil d'un utilisateur ou d'une entité.
+   * Constant : PROFIL_IMAGE
+   */
+  async updateImageProfil({ profil_avatar: image  }) {
+    image = await this.validateImage(image);
+    const data = { pathParams: { folder: this.getEntityType(), ownerId: this.id },  profil_avatar: image };
+    return this.callIsConnected(() => this.endpointApi.profilImage(data));
+  }
+};
+  

package/src/mixin/MutualEntityMixin.js

@@ -0,0 +1,48 @@
+import { ApiResponseError } from "../error.js";
+
+// MutualEntityMixin.js
+export const MutualEntityMixin = {
+  /**
+     * Résout l'identifiant de l'entité si seul le slug est fourni.
+     * @param {string} type - Le type d'entité (ex : "citoyens", "organizations", "projects").
+     * @returns {Promise<string>} L'identifiant résolu.
+     */
+  async resolveId(type) {
+    if (!this.id && this.slug) {
+      try {
+        const data = await this.endpointApi.getElementsKey({
+          pathParams:{
+            slug: this.slug
+          }
+        });
+        if(data?.contextId && data?.contextType === type) {
+          this._id(data.contextId);
+        } else {
+          throw new ApiResponseError(`Le slug ${this.slug} ne correspond pas à un ${type}`, 200, data);
+        }
+      } catch (error) {
+        if(error instanceof ApiResponseError) {
+          if(error?.responseData?.contextType !== type) {
+            throw error;
+          } else {
+            throw new ApiResponseError(`Impossible de récupérer l'identifiant pour le slug ${this.slug}`, error.status, error.responseData);
+          }
+        } else {
+          throw error;
+        }
+      }
+    }
+    return this.id;
+  },
+  
+  /**
+     * Récupère le profil public de l'entité.
+     * @returns {Promise<Object>} Les données du profil public.
+     */
+  async getPublicProfile() {
+    await this.resolveId(this.getEntityType());
+    return this.endpointApi.getElementsAbout({ pathParams: { id: this.id, type: this.getEntityType() } });
+  }
+
+};
+  

package/src/mixin/NewsMixin.js

@@ -0,0 +1,42 @@
+import { ApiResponseError } from "../error.js";
+
+// NewsMixin.js
+export const NewsMixin = {
+  /**
+   * Récupérer les actualités : Récupère la liste d’actualités selon plusieurs critères.
+   * Constant : GET_NEWS
+   * @param {Object} data - Les données à envoyer.
+   * @param {number} data.dateLimit - Limite de date timestamp ou 0 (default: 0)
+   * @param {object} data.search - data.search
+   * @param {string} data.search.name - Nom ou terme recherché (default: "")
+   * @param {number} data.indexStep - Nombre de résultats par page (default: 12)
+   * @returns {Promise<Object>} - Les données de réponse.
+   * @throws {ApiResponseError} - En cas d'erreur détectée dans la réponse.
+   * @throws {Error} - En cas d'erreur inattendue.
+   */
+  async getNews(data = {}) {
+    data.pathParams = { type: this.getEntityType(), id: this.id };
+    const arrayObjetNews =  await this.endpointApi.getNews(data);
+    if(!Array.isArray(arrayObjetNews)){
+      throw new ApiResponseError("Erreur lors de la récupération des actualités.", 500, arrayObjetNews);
+    }
+    const rawNewsList = arrayObjetNews.map((newsData) =>
+      this.deps.News.fromServerData(newsData, this, { User : this.deps.User, EndpointApi: this.deps.EndpointApi })
+    );
+    return this._createFilteredProxy(rawNewsList);
+  },
+
+  async news(newsData) {
+    try {
+      const news = new this.deps.News(this, newsData, { User: this.deps.User, EndpointApi : this.deps.EndpointApi });
+      if (newsData.id) {
+        await news.get();
+      }
+      return news;
+    } catch (error) {
+      this.apiClient._logger.error(`[Api.${this.getEntityType()}.news] Erreur lors de la création d'une instance news :`, error.message);
+      throw error;
+    }
+  }
+};
+  

package/src/mixin/UserMixin.js

@@ -0,0 +1,8 @@
+// eslint-disable-next-line no-unused-vars
+import { ApiResponseError } from "../error.js";
+
+// UserMixin.js
+export const UserMixin = {
+
+};
+  

package/src/mixin/UtilMixin.js

@@ -0,0 +1,294 @@
+import ObjectID from "bson-objectid";
+import { fileTypeFromBuffer } from "file-type";
+
+import { ApiAuthenticationError, ApiValidationError } from "../error.js";
+
+// UtilMixin.js
+export const UtilMixin = {
+
+  /**
+   * Appelle une méthode de l'API.
+   * 
+   * @param {string} constant - Le nom de la méthode à appeler.
+   * @param {object} data - Les données à passer à la méthode.
+   * @returns {Promise<any>} - La promesse de la méthode appelée.
+   * @throws {ApiValidationError} - Si une erreur se produit lors de l'appel de l'API.
+   * @throws {ApiResponseError} - Si une erreur se produit lors de l'appel de l'API.
+   * @throws {ApiClientError} - Si l'utilisateur n'est pas authentifié.
+   */
+  async call(constant, data = {}) {
+    return this.apiClient.safeCall(async () => {
+      const response = await this.apiClient.callEndpoint(constant, data);
+      this.apiClient.checkAndThrowApiResponseError(response);
+      return response.data;
+    });
+  },
+
+  /**
+   * Appelle une méthode de l'API si l'utilisateur n'est pas connecté.
+   * 
+   * @param {string} constant - Le nom de la méthode à appeler.
+   * @param {object} data - Les données à passer à la méthode.
+   * @returns {Promise<any>} - La promesse de la méthode appelée.
+   * @throws {ApiAuthenticationError} - Si l'utilisateur est connecté.
+   * @throws {ApiValidationError} - Si une erreur se produit lors de l'appel de l'API.
+   * @throws {ApiResponseError} - Si une erreur se produit lors de l'appel de l'API.
+   * @throws {ApiClientError} - Si une erreur se produit lors de l'appel de l'API.
+   */
+  async callNoConnected(constant, data = {}) {
+    if(this.isConnected) {
+      throw new ApiAuthenticationError("Vous devez ne devez pas être connecté pour faire cette action.");
+    }
+    return this.call(constant, data);
+  },
+
+  /**
+   * Appelle une méthode de l'API si l'utilisateur est connecté.
+   * 
+   * @param {string|function} param - Le nom de la méthode à appeler ou une fonction de rappel.
+   * @param {object} data - Les données à passer à la méthode.
+   * @returns {Promise<any>} - La promesse de la méthode appelée.
+   * @throws {ApiAuthenticationError} - Si l'utilisateur n'est pas connecté.
+   * @throws {ApiValidationError} - Si une erreur se produit lors de l'appel de l'API.
+   * @throws {ApiResponseError} - Si une erreur se produit lors de l'appel de l'API.
+   * @throws {ApiClientError} - Si une erreur se produit lors de l'appel de l'API.
+   */
+  async callIsConnected(param, data = {}) {
+    if(!this.isConnected) {
+      throw new ApiAuthenticationError("Vous devez être connecté pour faire cette action.");
+    }
+    // Si le premier paramètre est une fonction, on l'exécute en tant que callback
+    if (typeof param === "function") {
+      return await param();
+    }
+    return this.call(param, data);
+  },
+
+  /**
+   * Appelle une méthode de l'API si l'utilisateur est lui-même.
+   * 
+   * @param {string|function} param - Le nom de la méthode à appeler ou une fonction de rappel.
+   * @param {object} data - Les données à passer à la méthode.
+   * @returns {Promise<any>} - La promesse de la méthode appelée.
+   * @throws {ApiAuthenticationError} - Si l'utilisateur n'est pas lui-même.
+   * @throws {ApiValidationError} - Si une erreur se produit lors de l'appel de l'API.
+   * @throws {ApiResponseError} - Si une erreur se produit lors de l'appel de l'API.
+   * @throws {ApiClientError} - Si une erreur se produit lors de l'appel de l'API.
+   */
+  async callIsMe(param, data = {}) {
+    if (!this.isMe) {
+      throw new ApiAuthenticationError("Vous devez être vous-même pour faire cette action.");
+    }
+    // Si le premier paramètre est une fonction, on l'exécute en tant que callback
+    if (typeof param === "function") {
+      return await param();
+    }
+    // Sinon, on considère qu'il s'agit d'un constant et on appelle la méthode par défaut
+    return await this.callIsConnected(param, data);
+  },
+
+  async validateImage(imageInput){
+    const image = await this._validateUploadInput(imageInput, {
+      allowedMimeTypes: ["image/jpeg", "image/png", "image/jpg"],
+      expectedType: "image"
+    });
+    return image;
+  },
+
+  async validateFile(fileInput){
+    const file = await this._validateUploadInput(fileInput, {
+      allowedMimeTypes: ["application/pdf", "text/plain", "text/csv"],
+      expectedType: "file"
+    });
+    return file;
+  },
+
+  async _validateUploadInput(input, { allowedMimeTypes = [], expectedType = "any" }) {
+    if (!input) {
+      throw new ApiValidationError("Le fichier est requis.");
+    }
+  
+    const isNode = typeof window === "undefined" && typeof process !== "undefined";
+    let mimeType = "";
+    let output = input;
+  
+    // Navigateur : File
+    if (typeof File !== "undefined" && input instanceof File) {
+      mimeType = input.type;
+      if (!allowedMimeTypes.includes(mimeType)) {
+        throw new ApiValidationError("Le type du fichier est invalide.");
+      }
+    }
+  
+    // Navigateur : Blob
+    else if (typeof Blob !== "undefined" && input instanceof Blob) {
+      mimeType = input.type;
+      if (!allowedMimeTypes.includes(mimeType)) {
+        throw new ApiValidationError("Le type du fichier est invalide.");
+      }
+  
+      const ext = mimeType.split("/")[1] || "bin";
+      const fileName = `${Date.now()}.${ext}`;
+      output = new File([input], fileName, { type: mimeType });
+    }
+  
+    // Node.js : Buffer
+    else if (isNode && Buffer.isBuffer(input)) {
+      const fileTypeResult = await fileTypeFromBuffer(input);
+      mimeType = fileTypeResult?.mime;
+  
+      if (!fileTypeResult || !allowedMimeTypes.includes(mimeType)) {
+        throw new ApiValidationError("Le type du fichier est invalide.");
+      }
+  
+      // Pour un fichier image, on transforme en stream
+      if (expectedType === "image") {
+        const ext = fileTypeResult.ext;
+        const filename = `${Date.now()}.${ext}`;
+        output = await this._createReadStreamFromBuffer(input, filename, mimeType);
+      }
+    }
+  
+    // Node.js : ReadableStream
+    else if (isNode && input?.readable && typeof input._read === "function") {
+      const previewChunks = [];
+      const tee = await this._passThrough();
+      const resultStream = await this._passThrough();
+  
+      const MAX_BYTES = 4100;
+      let bytesRead = 0;
+  
+      input.on("data", (chunk) => {
+        if (bytesRead < MAX_BYTES) {
+          previewChunks.push(chunk);
+          bytesRead += chunk.length;
+        }
+      });
+  
+      input.pipe(tee).pipe(resultStream);
+      await new Promise((resolve) => setTimeout(resolve, 10));
+  
+      const previewBuffer = Buffer.concat(previewChunks);
+      const fileTypeResult = await fileTypeFromBuffer(previewBuffer);
+      mimeType = fileTypeResult?.mime;
+  
+      if (!fileTypeResult || !allowedMimeTypes.includes(mimeType)) {
+        throw new ApiValidationError("Le type du fichier est invalide.");
+      }
+  
+      resultStream.path = `${Date.now()}.${fileTypeResult.ext}`;
+      resultStream.mimeType = mimeType;
+      output = resultStream;
+    }
+  
+    else {
+      throw new ApiValidationError("Type de fichier non reconnu.");
+    }
+  
+    return output;
+  },
+
+  /**
+ * Transforme un Buffer en ReadableStream équivalent à fs.createReadStream
+ * @param {Buffer} buffer - Le buffer contenant les données binaires
+ * @param {string} filename - Nom de fichier (utilisé dans FormData)
+ * @param {string} mimeType - Type MIME (utilisé dans FormData)
+ * @returns {Object} - { stream, filename, mimeType }
+ */
+  async _createReadStreamFromBuffer(buffer, filename = "file.bin", mimeType = "application/octet-stream") {
+    const stream = await this._bufferToReadable(buffer);
+    stream.path = filename; // 👈 hack pour simuler un vrai fichier ReadStream
+    stream.mimeType = mimeType;
+    return stream;
+  },
+
+  async _bufferToReadable(buffer) {
+    if (typeof window === "undefined") {
+      const { bufferToReadable } = await import("../utils/stream-utils.node.js");
+      return bufferToReadable(buffer);
+    } else {
+      throw new Error("bufferToReadable ne doit pas être appelé dans le navigateur");
+    }
+  },
+  
+  async _passThrough() {
+    if (typeof window === "undefined") {
+      const { createPassThrough } = await import("../utils/stream-utils.node.js");
+      return createPassThrough();
+    } else {
+      throw new Error("passThrough ne doit pas être appelé dans le navigateur");
+    }
+  },
+
+  // async _bufferToReadable(buffer) {
+  //   if (typeof window === "undefined") {
+  //     const { Readable } = await import("stream");
+  //     return Readable.from(buffer);
+  //   } else {
+  //     throw new Error("bufferToReadable ne doit pas être appelé dans le navigateur");
+  //   }
+  // },
+
+  // async _passThrough() {
+  //   if (typeof window === "undefined") {
+  //     const { PassThrough } = await import("stream");
+  //     return new PassThrough();
+  //   } else {
+  //     throw new Error("passThrough ne doit pas être appelé dans le navigateur");
+  //   }
+  // },
+
+  _omitProps(obj, propsToRemove) {
+    if (!obj || typeof obj !== "object") return {};
+  
+    const result = { ...obj };
+    for (const prop of propsToRemove) {
+      delete result[prop];
+    }
+    return result;
+  },
+
+  _pickProps(obj, keys, transforms = {}) {
+    if (!obj || typeof obj !== "object") return {};
+
+    const result = {};
+
+    for (const key of keys) {
+      if (key in obj) {
+        const value = obj[key];
+        if (typeof transforms[key] === "function") {
+          result[key] = transforms[key](value, obj); // (valeur, objet source)
+        } else {
+          result[key] = value;
+        }
+      }
+    }
+
+    return result;
+  },
+
+  _createFilteredProxy(list) {
+    return new Proxy(list, {
+      get(target, prop, receiver) {
+        if (typeof prop === "string" && !isNaN(prop)) {
+          const active = target.filter(n => !n._isDeleted);
+          return active[prop];
+        }
+        if (prop === "length") {
+          return target.filter(n => !n._isDeleted).length;
+        }
+        if (typeof target[prop] === "function") {
+          return (...args) => target.filter(n => !n._isDeleted)[prop](...args);
+        }
+        return Reflect.get(target, prop, receiver);
+      }
+    });
+  },
+  
+  _newId() {
+    const newId = new ObjectID();
+    return newId.toString();
+  }
+  
+};
+  

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

@@ -0,0 +1,10 @@
+// utils/stream-utils.node.js
+export async function bufferToReadable(buffer) {
+  const { Readable } = await import("stream");
+  return Readable.from(buffer);
+}
+  
+export async function createPassThrough() {
+  const { PassThrough } = await import("stream");
+  return new PassThrough();
+}

package/dist/cocolight-api-client.cjs.LICENSE.txt

@@ -1 +0,0 @@
-/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */

package/dist/cocolight-api-client.mjs.js.LICENSE.txt

@@ -1 +0,0 @@
-/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */