@autorender/sdk-core 0.1.21 → 0.1.23

package/README.md

@@ -112,6 +112,7 @@ Creates a new AutoRender client instance for image transformations.
 ### `ARInstance`
 
 - `url(src: string, transform?: TransformOptions): string` - Generate transformed image URL
+  - `src` supports workspace paths (e.g., `products/shoe.jpg`) and absolute remote URLs (e.g., `https://example.com/image.jpg`).
 - `transformString(transform: TransformOptions): string` - Get transformation string only
 - `responsiveImageAttributes(options: ResponsiveOptions): ResponsiveAttributes` - Generate responsive image attributes
 - `getDPR(): number` - Get device pixel ratio (1 or 2)

package/dist/index.cjs

@@ -23,6 +23,7 @@ __export(src_exports, {
   createAR: () => createAR,
   createUploader: () => createUploader,
   detectBestFormat: () => detectBestFormat,
+  encodeAssetPathForDelivery: () => encodeAssetPathForDelivery,
   getBestFormatSync: () => getBestFormatSync,
   registerAutorenderUploaderElement: () => registerAutorenderUploaderElement,
   resetFormatCache: () => resetFormatCache
@@ -183,129 +184,86 @@ var AutorenderApiClient = class {
     this.apiKey = opts.apiKey;
     this.baseUrl = (opts.baseUrl || getBaseUrl(opts.environment || "prod")).replace(/\/+$/, "");
   }
-  async generateToken(params) {
+  uploadFile(params, onProgress, signal) {
     return new Promise((resolve, reject) => {
+      if (signal?.aborted) {
+        reject(new DOMException("Upload aborted", "AbortError"));
+        return;
+      }
       const xhr = new XMLHttpRequest();
+      if (signal) {
+        signal.addEventListener("abort", () => {
+          xhr.abort();
+          reject(new DOMException("Upload aborted", "AbortError"));
+        });
+      }
+      let lastProgress = 0;
+      xhr.upload.onprogress = (event) => {
+        if (event.lengthComputable && onProgress) {
+          const progress = Math.round(event.loaded / event.total * 100);
+          lastProgress = progress;
+          onProgress(progress);
+        } else if (onProgress && event.loaded > 0) {
+          const estimatedProgress = Math.min(
+            95,
+            Math.round(event.loaded / (event.loaded + 1e6) * 100)
+          );
+          if (estimatedProgress > lastProgress) {
+            lastProgress = estimatedProgress;
+            onProgress(estimatedProgress);
+          }
+        }
+      };
       xhr.onerror = () => {
-        reject(new Error(`Failed to generate token: ${xhr.statusText}`));
+        reject(new Error(`Upload failed: ${xhr.statusText}`));
       };
       xhr.onload = () => {
         try {
           if (xhr.status < 200 || xhr.status >= 300) {
             const errorText = xhr.responseText || xhr.statusText;
-            reject(new Error(`Failed to generate token: ${errorText}`));
-            return;
-          }
-          const response = JSON.parse(xhr.responseText);
-          if (!response.token) {
-            reject(new Error("Token not found in response"));
+            reject(new Error(`Upload failed: ${errorText}`));
             return;
           }
-          resolve(response.token);
+          const newResponse = JSON.parse(xhr.responseText);
+          const response = {
+            success: true,
+            file_no: newResponse.file_no || newResponse.id,
+            name: newResponse.name,
+            url: newResponse.url,
+            file_size: newResponse.size,
+            format: newResponse.format,
+            width: newResponse.width,
+            height: newResponse.height,
+            created_at: newResponse.created_at,
+            path: newResponse.path,
+            workspace_no: newResponse.workspace_id,
+            isDuplicate: newResponse.is_duplicate || false
+          };
+          resolve(response);
         } catch (error) {
-          reject(new Error("Failed to parse token response"));
+          reject(new Error("Failed to parse response"));
         }
       };
-      let folder = params.folderPath || "";
-      if (params.relativePath) {
-        folder = folder ? `${folder}/${params.relativePath}` : params.relativePath;
+      const endpoint = `${this.baseUrl}/uploads`;
+      const formData = new FormData();
+      formData.append("file", params.file);
+      formData.append("file_name", params.file.name);
+      if (params.folderPath) {
+        formData.append("folder", params.folderPath);
       }
-      if (folder && !folder.endsWith("/")) {
-        folder += "/";
+      if (params.settings?.tags?.length) {
+        formData.append("tags", params.settings.tags.join(","));
+      }
+      if (params.settings?.pretransformations) {
+        formData.append("transform", params.settings.pretransformations);
+      }
+      if (params.settings?.custom_id) {
+        formData.append("custom_id", params.settings.custom_id);
       }
-      const tokenRequest = {
-        file_name: params.file.name,
-        ...folder && { folder },
-        ...params.settings?.tags && { tags: params.settings.tags },
-        ...params.settings?.pretransformations && { transform: params.settings.pretransformations },
-        max_file_size: params.file.size,
-        allow_override: {
-          folder: true,
-          tags: true,
-          transform: true
-        },
-        random_prefix: !params.settings?.is_unique_suffix_name
-      };
-      const endpoint = `${this.baseUrl}/generate-token`;
       xhr.open("POST", endpoint);
       xhr.setRequestHeader("Authorization", `Bearer ${this.apiKey}`);
-      xhr.setRequestHeader("Content-Type", "application/json");
       xhr.setRequestHeader("accept", "application/json");
-      xhr.send(JSON.stringify(tokenRequest));
-    });
-  }
-  uploadFile(params, onProgress, signal) {
-    return new Promise(async (resolve, reject) => {
-      if (signal?.aborted) {
-        reject(new DOMException("Upload aborted", "AbortError"));
-        return;
-      }
-      try {
-        const token = await this.generateToken(params);
-        if (signal?.aborted) {
-          reject(new DOMException("Upload aborted", "AbortError"));
-          return;
-        }
-        const xhr = new XMLHttpRequest();
-        if (signal) {
-          signal.addEventListener("abort", () => {
-            xhr.abort();
-            reject(new DOMException("Upload aborted", "AbortError"));
-          });
-        }
-        let lastProgress = 0;
-        xhr.upload.onprogress = (event) => {
-          if (event.lengthComputable && onProgress) {
-            const progress = Math.round(event.loaded / event.total * 100);
-            lastProgress = progress;
-            onProgress(progress);
-          } else if (onProgress && event.loaded > 0) {
-            const estimatedProgress = Math.min(95, Math.round(event.loaded / (event.loaded + 1e6) * 100));
-            if (estimatedProgress > lastProgress) {
-              lastProgress = estimatedProgress;
-              onProgress(estimatedProgress);
-            }
-          }
-        };
-        xhr.onerror = () => {
-          reject(new Error(`Upload failed: ${xhr.statusText}`));
-        };
-        xhr.onload = () => {
-          try {
-            if (xhr.status < 200 || xhr.status >= 300) {
-              const errorText = xhr.responseText || xhr.statusText;
-              reject(new Error(`Upload failed: ${errorText}`));
-              return;
-            }
-            const newResponse = JSON.parse(xhr.responseText);
-            const response = {
-              success: true,
-              file_no: newResponse.file_no || newResponse.id,
-              name: newResponse.name,
-              url: newResponse.url,
-              file_size: newResponse.size,
-              format: newResponse.format,
-              width: newResponse.width,
-              height: newResponse.height,
-              created_at: newResponse.created_at,
-              path: newResponse.path,
-              workspace_no: newResponse.workspace_id,
-              isDuplicate: newResponse.is_duplicate || false
-            };
-            resolve(response);
-          } catch (error) {
-            reject(new Error("Failed to parse response"));
-          }
-        };
-        const endpoint = `${this.baseUrl}/uploads/${token}`;
-        xhr.open("POST", endpoint);
-        xhr.setRequestHeader("accept", "application/json");
-        const mimeType = params.file.type || "application/octet-stream";
-        xhr.setRequestHeader("Content-Type", mimeType);
-        xhr.send(params.file);
-      } catch (error) {
-        reject(error);
-      }
+      xhr.send(formData);
     });
   }
 };
@@ -708,7 +666,8 @@ var UploaderController = class extends EventTarget {
         settings: uploadSettings ? {
           pretransformations: uploadSettings.pretransformations,
           tags: uploadSettings.tags,
-          is_unique_suffix_name: uploadSettings.is_unique_suffix_name ?? false
+          is_unique_suffix_name: uploadSettings.is_unique_suffix_name ?? false,
+          custom_id: uploadSettings.custom_id
         } : void 0
       },
       (progress) => {
@@ -3576,15 +3535,40 @@ function normalizePlacement(placement) {
 }
 
 // src/viewtag/url-builder.ts
+var ABSOLUTE_URL_RE = /^https?:\/\//i;
+function encodeAssetPathForDelivery(src) {
+  const trimmed = src.trim();
+  if (!trimmed) {
+    return "";
+  }
+  if (ABSOLUTE_URL_RE.test(trimmed)) {
+    const fetchPayload = `fetch_${trimmed}`;
+    return encodeURIComponent(fetchPayload);
+  }
+  if (trimmed.startsWith("fetch_")) {
+    return encodeURIComponent(trimmed);
+  }
+  return trimmed.split("/").filter(Boolean).map((segment) => encodeURIComponent(segment)).join("/");
+}
 function buildImageUrl(baseUrl, workspace, src, transform, defaults, enableDPR = true, connectionQuality) {
   const normalizedBase = baseUrl.replace(/\/+$/, "");
   const transformStr = buildTransformString(transform || {}, defaults, enableDPR, connectionQuality);
-  const encodedPath = src.split("/").filter(Boolean).map((segment) => encodeURIComponent(segment)).join("/");
+  const trimmedSrc = src.trim();
+  if (ABSOLUTE_URL_RE.test(trimmedSrc)) {
+    const fetchPart = `fetch_${trimmedSrc}`;
+    const transformWithFetch = transformStr ? `${transformStr},${fetchPart}` : fetchPart;
+    return `${normalizedBase}/${workspace}/${transformWithFetch}`;
+  }
+  if (trimmedSrc.startsWith("fetch_")) {
+    const fetchPart = trimmedSrc;
+    const transformWithFetch = transformStr ? `${transformStr},${fetchPart}` : fetchPart;
+    return `${normalizedBase}/${workspace}/${transformWithFetch}`;
+  }
+  const encodedPath = encodeAssetPathForDelivery(trimmedSrc);
   if (transformStr) {
     return `${normalizedBase}/${workspace}/${transformStr}/${encodedPath}`;
-  } else {
-    return `${normalizedBase}/${workspace}/${encodedPath}`;
   }
+  return `${normalizedBase}/${workspace}/${encodedPath}`;
 }
 
 // src/viewtag/responsive.ts
@@ -3967,6 +3951,7 @@ function registerAutorenderUploaderElement() {
   createAR,
   createUploader,
   detectBestFormat,
+  encodeAssetPathForDelivery,
   getBestFormatSync,
   registerAutorenderUploaderElement,
   resetFormatCache