@edgestore/react 0.6.0-canary.1 → 0.6.0-canary.2

package/dist/contextProvider.d.ts

@@ -0,0 +1,65 @@
+import { type AnyRouter } from '@edgestore/shared';
+import * as React from 'react';
+import { type BucketFunctions } from './createNextProxy';
+type EdgeStoreContextValue<TRouter extends AnyRouter> = {
+    edgestore: BucketFunctions<TRouter>;
+    /**
+     * This will re-run the EdgeStore initialization process,
+     * which will run the `createContext` function again.
+     *
+     * Can be used after a sign-in or sign-out, for example.
+     */
+    reset: () => Promise<void>;
+    /**
+     * The current state of the EdgeStore provider.
+     *
+     * You can use this to wait for the provider to be initialized
+     * before trying to show private images on your app.
+     */
+    state: ProviderState;
+};
+export declare function createEdgeStoreProvider<TRouter extends AnyRouter>(opts?: {
+    /**
+     * The maximum number of concurrent uploads.
+     *
+     * Uploads will automatically be queued if this limit is reached.
+     *
+     * @default 5
+     */
+    maxConcurrentUploads?: number;
+    /**
+     * Accessing EdgeStore protected files in development mode requires a proxy.
+     * You might want to disable this for other providers if you are overwriting the path.
+     *
+     * @default false
+     */
+    disableDevProxy?: boolean;
+}): {
+    EdgeStoreProvider: ({ children, basePath, }: {
+        children: React.ReactNode;
+        /**
+         * In case your app is not hosted at the root of your domain, you can specify the base path here.
+         * If you set this, make sure to set the full path to the EdgeStore API.
+         * e.g. `/my-app/api/edgestore` or `https://example.com/my-app/api/edgestore`
+         *
+         * @example - If your app is hosted at `https://example.com/my-app`, you can set the `basePath` to `/my-app/api/edgestore`.
+         */
+        basePath?: string;
+    }) => React.JSX.Element;
+    useEdgeStore: () => EdgeStoreContextValue<TRouter>;
+};
+type ProviderState = {
+    loading: true;
+    initialized: false;
+    error: false;
+} | {
+    loading: false;
+    initialized: false;
+    error: true;
+} | {
+    loading: false;
+    initialized: true;
+    error: false;
+};
+export {};
+//# sourceMappingURL=contextProvider.d.ts.map

package/dist/contextProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contextProvider.d.ts","sourceRoot":"","sources":["../src/contextProvider.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAAmB,KAAK,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAU1E,KAAK,qBAAqB,CAAC,OAAO,SAAS,SAAS,IAAI;IACtD,SAAS,EAAE,eAAe,CAAC,OAAO,CAAC,CAAC;IACpC;;;;;OAKG;IACH,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3B;;;;;OAKG;IACH,KAAK,EAAE,aAAa,CAAC;CACtB,CAAC;AAEF,wBAAgB,uBAAuB,CAAC,OAAO,SAAS,SAAS,EAAE,IAAI,CAAC,EAAE;IACxE;;;;;;OAMG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B;;;;;OAKG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;iDAQI;QACD,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;QAC1B;;;;;;WAMG;QACH,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB;;EA+BF;AAED,KAAK,aAAa,GACd;IACE,OAAO,EAAE,IAAI,CAAC;IACd,WAAW,EAAE,KAAK,CAAC;IACnB,KAAK,EAAE,KAAK,CAAC;CACd,GACD;IACE,OAAO,EAAE,KAAK,CAAC;IACf,WAAW,EAAE,KAAK,CAAC;IACnB,KAAK,EAAE,IAAI,CAAC;CACb,GACD;IACE,OAAO,EAAE,KAAK,CAAC;IACf,WAAW,EAAE,IAAI,CAAC;IAClB,KAAK,EAAE,KAAK,CAAC;CACd,CAAC"}

package/dist/createNextProxy.d.ts

@@ -0,0 +1,71 @@
+import { type AnyRouter, type InferBucketPathObject, type InferMetadataObject, type UploadOptions } from '@edgestore/shared';
+import { type z } from 'zod';
+/**
+ * @internal
+ * @see https://www.totaltypescript.com/concepts/the-prettify-helper
+ */
+export type Prettify<TType> = {
+    [K in keyof TType]: TType[K];
+} & {};
+export type BucketFunctions<TRouter extends AnyRouter> = {
+    [K in keyof TRouter['buckets']]: {
+        /**
+         * Upload a file to the bucket
+         *
+         * @example
+         * await edgestore.myBucket.upload({
+         *  file: file,
+         *  signal: abortController.signal, // if you want to be able to cancel the ongoing upload
+         *  onProgressChange: (progress) => { console.log(progress) }, // if you want to show the progress of the upload
+         *  input: {...} // if the bucket has an input schema
+         *  options: {
+         *   manualFileName: file.name, // if you want to use a custom file name
+         *   replaceTargetUrl: url, // if you want to replace an existing file
+         *   temporary: true, // if you want to delete the file after 24 hours
+         *  }
+         * })
+         */
+        upload: (params: z.infer<TRouter['buckets'][K]['_def']['input']> extends never ? {
+            file: File;
+            signal?: AbortSignal;
+            onProgressChange?: OnProgressChangeHandler;
+            options?: UploadOptions;
+        } : {
+            file: File;
+            signal?: AbortSignal;
+            input: z.infer<TRouter['buckets'][K]['_def']['input']>;
+            onProgressChange?: OnProgressChangeHandler;
+            options?: UploadOptions;
+        }) => Promise<TRouter['buckets'][K]['_def']['type'] extends 'IMAGE' ? {
+            url: string;
+            thumbnailUrl: string | null;
+            size: number;
+            uploadedAt: Date;
+            metadata: InferMetadataObject<TRouter['buckets'][K]>;
+            path: InferBucketPathObject<TRouter['buckets'][K]>;
+            pathOrder: Prettify<keyof InferBucketPathObject<TRouter['buckets'][K]>>[];
+        } : {
+            url: string;
+            size: number;
+            uploadedAt: Date;
+            metadata: InferMetadataObject<TRouter['buckets'][K]>;
+            path: InferBucketPathObject<TRouter['buckets'][K]>;
+            pathOrder: Prettify<keyof InferBucketPathObject<TRouter['buckets'][K]>>[];
+        }>;
+        confirmUpload: (params: {
+            url: string;
+        }) => Promise<void>;
+        delete: (params: {
+            url: string;
+        }) => Promise<void>;
+    };
+};
+type OnProgressChangeHandler = (progress: number) => void;
+export declare function createNextProxy<TRouter extends AnyRouter>({ apiPath, uploadingCountRef, maxConcurrentUploads, disableDevProxy, }: {
+    apiPath: string;
+    uploadingCountRef: React.MutableRefObject<number>;
+    maxConcurrentUploads?: number;
+    disableDevProxy?: boolean;
+}): BucketFunctions<TRouter>;
+export {};
+//# sourceMappingURL=createNextProxy.d.ts.map

package/dist/createNextProxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createNextProxy.d.ts","sourceRoot":"","sources":["../src/createNextProxy.ts"],"names":[],"mappings":"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"}

package/dist/errors/index.d.ts

@@ -0,0 +1,3 @@
+export { EdgeStoreApiClientError } from '@edgestore/shared';
+export { UploadAbortedError } from '../libs/errors/uploadAbortedError';
+//# sourceMappingURL=index.d.ts.map

package/dist/errors/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/errors/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AAC5D,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC"}

package/dist/errors/index.js

@@ -0,0 +1,14 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var shared = require('@edgestore/shared');
+var uploadAbortedError = require('../uploadAbortedError-fbfcc57b.js');
+
+
+
+Object.defineProperty(exports, 'EdgeStoreApiClientError', {
+	enumerable: true,
+	get: function () { return shared.EdgeStoreApiClientError; }
+});
+exports.UploadAbortedError = uploadAbortedError.UploadAbortedError;

package/dist/errors/index.mjs

@@ -1,4 +1,2 @@
-import { t as UploadAbortedError } from "../uploadAbortedError-1Hka0_24.mjs";
-import { EdgeStoreApiClientError } from "@edgestore/shared";
-
-export { EdgeStoreApiClientError, UploadAbortedError };
+export { EdgeStoreApiClientError } from '@edgestore/shared';
+export { U as UploadAbortedError } from '../uploadAbortedError-e1379bb0.mjs';

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './contextProvider';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC"}

package/dist/index.js

@@ -0,0 +1,488 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+var shared = require('@edgestore/shared');
+var uploadAbortedError = require('./uploadAbortedError-fbfcc57b.js');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+
+class EdgeStoreClientError extends Error {
+    constructor(message){
+        super(message);
+        this.name = 'EdgeStoreError';
+    }
+}
+
+async function handleError(res) {
+    let json = {};
+    try {
+        json = await res.json();
+    } catch (err) {
+        throw new EdgeStoreClientError(`Failed to parse response. Make sure the api is correctly configured at ${res.url}`);
+    }
+    throw new shared.EdgeStoreApiClientError({
+        response: json
+    });
+}
+
+function createNextProxy({ apiPath, uploadingCountRef, maxConcurrentUploads = 5, disableDevProxy }) {
+    return new Proxy({}, {
+        get (_, prop) {
+            const bucketName = prop;
+            const bucketFunctions = {
+                upload: async (params)=>{
+                    try {
+                        params.onProgressChange?.(0);
+                        // This handles the case where the user cancels the upload while it's waiting in the queue
+                        const abortPromise = new Promise((resolve)=>{
+                            params.signal?.addEventListener('abort', ()=>{
+                                resolve();
+                            }, {
+                                once: true
+                            });
+                        });
+                        while(uploadingCountRef.current >= maxConcurrentUploads && uploadingCountRef.current > 0){
+                            await Promise.race([
+                                new Promise((resolve)=>setTimeout(resolve, 300)),
+                                abortPromise
+                            ]);
+                            if (params.signal?.aborted) {
+                                throw new uploadAbortedError.UploadAbortedError('File upload aborted');
+                            }
+                        }
+                        uploadingCountRef.current++;
+                        const fileInfo = await uploadFile(params, {
+                            bucketName: bucketName,
+                            apiPath
+                        }, disableDevProxy);
+                        return fileInfo;
+                    } finally{
+                        uploadingCountRef.current--;
+                    }
+                },
+                confirmUpload: async (params)=>{
+                    const { success } = await confirmUpload(params, {
+                        bucketName: bucketName,
+                        apiPath
+                    });
+                    if (!success) {
+                        throw new EdgeStoreClientError('Failed to confirm upload');
+                    }
+                },
+                delete: async (params)=>{
+                    const { success } = await deleteFile(params, {
+                        bucketName: bucketName,
+                        apiPath
+                    });
+                    if (!success) {
+                        throw new EdgeStoreClientError('Failed to delete file');
+                    }
+                }
+            };
+            return bucketFunctions;
+        }
+    });
+}
+async function uploadFile({ file, signal, input, onProgressChange, options }, { apiPath, bucketName }, disableDevProxy) {
+    try {
+        onProgressChange?.(0);
+        const res = await fetch(`${apiPath}/request-upload`, {
+            method: 'POST',
+            credentials: 'include',
+            signal: signal,
+            body: JSON.stringify({
+                bucketName,
+                input,
+                fileInfo: {
+                    extension: file.name.split('.').pop(),
+                    type: file.type,
+                    size: file.size,
+                    fileName: options?.manualFileName,
+                    replaceTargetUrl: options?.replaceTargetUrl,
+                    temporary: options?.temporary
+                }
+            }),
+            headers: {
+                'Content-Type': 'application/json'
+            }
+        });
+        if (!res.ok) {
+            await handleError(res);
+        }
+        const json = await res.json();
+        if ('multipart' in json) {
+            await multipartUpload({
+                bucketName,
+                multipartInfo: json.multipart,
+                onProgressChange,
+                signal,
+                file,
+                apiPath
+            });
+        } else if ('uploadUrl' in json) {
+            // Single part upload
+            // Upload the file to the signed URL and get the progress
+            await uploadFileInner({
+                file,
+                uploadUrl: json.uploadUrl,
+                onProgressChange,
+                signal
+            });
+        } else {
+            throw new EdgeStoreClientError('An error occurred');
+        }
+        return {
+            url: getUrl(json.accessUrl, apiPath, disableDevProxy),
+            thumbnailUrl: json.thumbnailUrl ? getUrl(json.thumbnailUrl, apiPath, disableDevProxy) : null,
+            size: json.size,
+            uploadedAt: new Date(json.uploadedAt),
+            path: json.path,
+            pathOrder: json.pathOrder,
+            metadata: json.metadata
+        };
+    } catch (e) {
+        if (e instanceof Error && e.name === 'AbortError') {
+            throw new uploadAbortedError.UploadAbortedError('File upload aborted');
+        }
+        onProgressChange?.(0);
+        throw e;
+    }
+}
+/**
+ * Protected files need third-party cookies to work.
+ * Since third party cookies don't work on localhost,
+ * we need to proxy the file through the server.
+ */ function getUrl(url, apiPath, disableDevProxy) {
+    const mode = typeof process !== 'undefined' ? process.env.NODE_ENV : undefined?.DEV ? 'development' : 'production';
+    if (mode === 'development' && !url.includes('/_public/') && !disableDevProxy) {
+        const proxyUrl = new URL(window.location.origin);
+        proxyUrl.pathname = `${apiPath}/proxy-file`;
+        proxyUrl.search = new URLSearchParams({
+            url
+        }).toString();
+        return proxyUrl.toString();
+    }
+    return url;
+}
+async function uploadFileInner(props) {
+    const { file, uploadUrl, onProgressChange, signal } = props;
+    const promise = new Promise((resolve, reject)=>{
+        if (signal?.aborted) {
+            reject(new uploadAbortedError.UploadAbortedError('File upload aborted'));
+            return;
+        }
+        const request = new XMLHttpRequest();
+        request.open('PUT', uploadUrl);
+        // This is for Azure provider. Specifies the blob type
+        request.setRequestHeader('x-ms-blob-type', 'BlockBlob');
+        request.addEventListener('loadstart', ()=>{
+            onProgressChange?.(0);
+        });
+        request.upload.addEventListener('progress', (e)=>{
+            if (e.lengthComputable) {
+                // 2 decimal progress
+                const progress = Math.round(e.loaded / e.total * 10000) / 100;
+                onProgressChange?.(progress);
+            }
+        });
+        request.addEventListener('error', ()=>{
+            reject(new Error('Error uploading file'));
+        });
+        request.addEventListener('abort', ()=>{
+            reject(new uploadAbortedError.UploadAbortedError('File upload aborted'));
+        });
+        request.addEventListener('loadend', ()=>{
+            // Return the ETag header (needed to complete multipart upload)
+            resolve(request.getResponseHeader('ETag'));
+        });
+        if (signal) {
+            signal.addEventListener('abort', ()=>{
+                request.abort();
+            });
+        }
+        request.send(file);
+    });
+    return promise;
+}
+async function multipartUpload(params) {
+    const { bucketName, multipartInfo, onProgressChange, file, signal, apiPath } = params;
+    const { partSize, parts, totalParts, uploadId, key } = multipartInfo;
+    const uploadingParts = [];
+    const uploadPart = async (params)=>{
+        const { part, chunk } = params;
+        const { uploadUrl } = part;
+        const eTag = await uploadFileInner({
+            file: chunk,
+            uploadUrl,
+            signal,
+            onProgressChange: (progress)=>{
+                const uploadingPart = uploadingParts.find((p)=>p.partNumber === part.partNumber);
+                if (uploadingPart) {
+                    uploadingPart.progress = progress;
+                } else {
+                    uploadingParts.push({
+                        partNumber: part.partNumber,
+                        progress
+                    });
+                }
+                const totalProgress = Math.round(uploadingParts.reduce((acc, p)=>acc + p.progress * 100, 0) / totalParts) / 100;
+                onProgressChange?.(totalProgress);
+            }
+        });
+        if (!eTag) {
+            throw new EdgeStoreClientError('Could not get ETag from multipart response');
+        }
+        return {
+            partNumber: part.partNumber,
+            eTag
+        };
+    };
+    // Upload the parts in parallel
+    const completedParts = await queuedPromises({
+        items: parts.map((part)=>({
+                part,
+                chunk: file.slice((part.partNumber - 1) * partSize, part.partNumber * partSize)
+            })),
+        fn: uploadPart,
+        maxParallel: 5,
+        maxRetries: 10
+    });
+    // Complete multipart upload
+    const res = await fetch(`${apiPath}/complete-multipart-upload`, {
+        method: 'POST',
+        credentials: 'include',
+        body: JSON.stringify({
+            bucketName,
+            uploadId,
+            key,
+            parts: completedParts
+        }),
+        headers: {
+            'Content-Type': 'application/json'
+        }
+    });
+    if (!res.ok) {
+        await handleError(res);
+    }
+}
+async function confirmUpload({ url }, { apiPath, bucketName }) {
+    const res = await fetch(`${apiPath}/confirm-upload`, {
+        method: 'POST',
+        credentials: 'include',
+        body: JSON.stringify({
+            url,
+            bucketName
+        }),
+        headers: {
+            'Content-Type': 'application/json'
+        }
+    });
+    if (!res.ok) {
+        await handleError(res);
+    }
+    return res.json();
+}
+async function deleteFile({ url }, { apiPath, bucketName }) {
+    const res = await fetch(`${apiPath}/delete-file`, {
+        method: 'POST',
+        credentials: 'include',
+        body: JSON.stringify({
+            url,
+            bucketName
+        }),
+        headers: {
+            'Content-Type': 'application/json'
+        }
+    });
+    if (!res.ok) {
+        await handleError(res);
+    }
+    return res.json();
+}
+async function queuedPromises({ items, fn, maxParallel, maxRetries = 0 }) {
+    const results = new Array(items.length);
+    const executeWithRetry = async (func, retries)=>{
+        try {
+            return await func();
+        } catch (error) {
+            if (error instanceof uploadAbortedError.UploadAbortedError) {
+                throw error;
+            }
+            if (retries > 0) {
+                await new Promise((resolve)=>setTimeout(resolve, 5000));
+                return executeWithRetry(func, retries - 1);
+            } else {
+                throw error;
+            }
+        }
+    };
+    const semaphore = {
+        count: maxParallel,
+        async wait () {
+            // If we've reached our maximum concurrency, or it's the last item, wait
+            while(this.count <= 0)await new Promise((resolve)=>setTimeout(resolve, 500));
+            this.count--;
+        },
+        signal () {
+            this.count++;
+        }
+    };
+    const tasks = items.map((item, i)=>(async ()=>{
+            await semaphore.wait();
+            try {
+                const result = await executeWithRetry(()=>fn(item), maxRetries);
+                results[i] = result;
+            } finally{
+                semaphore.signal();
+            }
+        })());
+    await Promise.all(tasks);
+    return results;
+}
+
+const DEFAULT_BASE_URL = (typeof process !== 'undefined' ? process.env.NEXT_PUBLIC_EDGE_STORE_BASE_URL : undefined?.EDGE_STORE_BASE_URL) ?? 'https://files.edgestore.dev';
+function createEdgeStoreProvider(opts) {
+    const EdgeStoreContext = /*#__PURE__*/ React__namespace.createContext(undefined);
+    const EdgeStoreProvider = ({ children, basePath })=>{
+        return EdgeStoreProviderInner({
+            children,
+            context: EdgeStoreContext,
+            basePath,
+            maxConcurrentUploads: opts?.maxConcurrentUploads,
+            disableDevProxy: opts?.disableDevProxy
+        });
+    };
+    function useEdgeStore() {
+        if (!EdgeStoreContext) {
+            throw new Error('React Context is unavailable in Server Components');
+        }
+        // @ts-expect-error - We know that the context value should not be undefined
+        const value = React__namespace.useContext(EdgeStoreContext);
+        if (!value && process.env.NODE_ENV !== 'production') {
+            throw new Error('[edgestore]: `useEdgeStore` must be wrapped in a <EdgeStoreProvider />');
+        }
+        return value;
+    }
+    return {
+        EdgeStoreProvider,
+        useEdgeStore
+    };
+}
+function EdgeStoreProviderInner({ children, context, basePath, maxConcurrentUploads, disableDevProxy }) {
+    const apiPath = basePath ? `${basePath}` : '/api/edgestore';
+    const [state, setState] = React__namespace.useState({
+        loading: true,
+        initialized: false,
+        error: false
+    });
+    const uploadingCountRef = React__namespace.useRef(0);
+    const initExecuted = React__namespace.useRef(false); // to make sure we don't run init twice
+    React__namespace.useEffect(()=>{
+        if (!initExecuted.current) {
+            void init();
+        }
+        return ()=>{
+            initExecuted.current = true;
+        };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    async function init() {
+        try {
+            setState({
+                loading: true,
+                initialized: false,
+                error: false
+            });
+            const res = await fetch(`${apiPath}/init`, {
+                method: 'POST',
+                credentials: 'include'
+            });
+            if (res.ok) {
+                const json = await res.json();
+                // Only call _init API if provider is edgestore
+                if (json.providerName === 'edgestore') {
+                    const innerRes = await fetch(`${DEFAULT_BASE_URL}/_init`, {
+                        method: 'GET',
+                        credentials: 'include',
+                        headers: {
+                            'x-edgestore-token': json.token
+                        }
+                    });
+                    if (innerRes.ok) {
+                        // update state
+                        setState({
+                            loading: false,
+                            initialized: true,
+                            error: false
+                        });
+                    } else {
+                        setState({
+                            loading: false,
+                            initialized: false,
+                            error: true
+                        });
+                        throw new EdgeStoreClientError("Couldn't initialize EdgeStore.");
+                    }
+                } else {
+                    // For non-edgestore providers, just update state without calling _init
+                    setState({
+                        loading: false,
+                        initialized: true,
+                        error: false
+                    });
+                }
+            } else {
+                setState({
+                    loading: false,
+                    initialized: false,
+                    error: true
+                });
+                await handleError(res);
+            }
+        } catch (err) {
+            setState({
+                loading: false,
+                initialized: false,
+                error: true
+            });
+            throw err;
+        }
+    }
+    async function reset() {
+        await init();
+    }
+    return /*#__PURE__*/ React__namespace.createElement(React__namespace.Fragment, null, /*#__PURE__*/ React__namespace.createElement(context.Provider, {
+        value: {
+            edgestore: createNextProxy({
+                apiPath,
+                uploadingCountRef,
+                maxConcurrentUploads,
+                disableDevProxy
+            }),
+            reset,
+            state
+        }
+    }, children));
+}
+
+exports.createEdgeStoreProvider = createEdgeStoreProvider;