@opendaw/studio-core 0.0.26 → 0.0.27

package/dist/clouds/CloudBackup.js

@@ -0,0 +1,55 @@
+import { DefaultObservableValue, Progress, RuntimeNotifier, RuntimeSignal } from "@opendaw/lib-std";
+import { CloudBackupSamples } from "./CloudBackupSamples";
+import { CloudBackupProjects } from "./CloudBackupProjects";
+import { ProjectSignals } from "../project/ProjectSignals";
+export var CloudBackup;
+(function (CloudBackup) {
+    CloudBackup.backup = async (cloudAuthManager, service) => {
+        const DialogMessage = `openDAW will never store or share your personal account details!
+                                        
+                                        Dropbox requires permission to read “basic account info” such as your name and email, but openDAW does not use or retain this information. We only access the files you choose to synchronize. 
+                                        
+                                        Clicking 'Sync' may open a new tab to authorize your dropbox.`;
+        const approved = await RuntimeNotifier.approve({
+            headline: "openDAW and your data",
+            message: DialogMessage,
+            approveText: "Sync",
+            cancelText: "Cancel"
+        });
+        if (!approved) {
+            return;
+        }
+        try {
+            const handler = await cloudAuthManager.getHandler(service);
+            await CloudBackup.backupWithHandler(handler, service);
+            await RuntimeNotifier.info({
+                headline: "Cloud Backup",
+                message: "Everything is up to date."
+            });
+        }
+        catch (reason) {
+            console.warn(reason);
+            await RuntimeNotifier.info({
+                headline: `Could not sync`,
+                message: String(reason)
+            });
+        }
+        finally {
+            RuntimeSignal.dispatch(ProjectSignals.StorageUpdated);
+        }
+    };
+    CloudBackup.backupWithHandler = async (cloudHandler, service) => {
+        const progressValue = new DefaultObservableValue(0.0);
+        const notification = RuntimeNotifier.progress({ headline: `Backup with ${service}`, progress: progressValue });
+        const log = (text) => notification.message = text;
+        const [progressSamples, progressProjects] = Progress.split(progress => progressValue.setValue(progress), 2);
+        try {
+            await CloudBackupSamples.start(cloudHandler, progressSamples, log);
+            await CloudBackupProjects.start(cloudHandler, progressProjects, log);
+        }
+        finally {
+            progressValue.terminate();
+            notification.terminate();
+        }
+    };
+})(CloudBackup || (CloudBackup = {}));

package/dist/clouds/CloudBackupProjects.d.ts

@@ -0,0 +1,10 @@
+import { Procedure, Progress } from "@opendaw/lib-std";
+import { CloudHandler } from "./CloudHandler";
+export declare class CloudBackupProjects {
+    #private;
+    static readonly RemotePath = "projects";
+    static readonly RemoteCatalogPath: string;
+    static start(cloudHandler: CloudHandler, progress: Progress.Handler, log: Procedure<string>): Promise<void>;
+    private constructor();
+}
+//# sourceMappingURL=CloudBackupProjects.d.ts.map

package/dist/clouds/CloudBackupProjects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CloudBackupProjects.d.ts","sourceRoot":"","sources":["../../src/clouds/CloudBackupProjects.ts"],"names":[],"mappings":"AAAA,OAAO,EAOH,SAAS,EACT,QAAQ,EAKX,MAAM,kBAAkB,CAAA;AAIzB,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAA;AAY3C,qBAAa,mBAAmB;;IAC5B,MAAM,CAAC,QAAQ,CAAC,UAAU,cAAa;IACvC,MAAM,CAAC,QAAQ,CAAC,iBAAiB,SAAkC;WAEtD,KAAK,CAAC,YAAY,EAAE,YAAY,EAC1B,QAAQ,EAAE,QAAQ,CAAC,OAAO,EAC1B,GAAG,EAAE,SAAS,CAAC,MAAM,CAAC;IAmBzC,OAAO;CAyJV"}

package/dist/clouds/CloudBackupProjects.js

@@ -0,0 +1,167 @@
+import { Arrays, Errors, isAbsent, Objects, panic, Progress, RuntimeNotifier, TimeSpan, UUID } from "@opendaw/lib-std";
+import { network, Promises } from "@opendaw/lib-runtime";
+import { ProjectStorage } from "../project/ProjectStorage";
+import { WorkerAgents } from "../WorkerAgents";
+import { ProjectPaths } from "../project/ProjectPaths";
+// these get indexed in the cloud with the uuid in the cloud's catalog
+const catalogFields = ["name", "modified", "created", "tags", "description"];
+export class CloudBackupProjects {
+    static RemotePath = "projects";
+    static RemoteCatalogPath = `${this.RemotePath}/index.json`;
+    static async start(cloudHandler, progress, log) {
+        log("Collecting all project domains...");
+        const [local, cloud] = await Promise.all([
+            ProjectStorage.listProjects()
+                .then(list => list.reduce((record, entry) => {
+                record[UUID.toString(entry.uuid)] = Objects.include(entry.meta, ...catalogFields);
+                return record;
+            }, {})),
+            cloudHandler.download(CloudBackupProjects.RemoteCatalogPath)
+                .then(json => JSON.parse(new TextDecoder().decode(json)))
+                .catch(reason => reason instanceof Errors.FileNotFound ? Arrays.empty() : panic(reason))
+        ]);
+        return new CloudBackupProjects(cloudHandler, { local, cloud }, log).#start(progress);
+    }
+    #cloudHandler;
+    #projectDomains;
+    #log;
+    constructor(cloudHandler, projectDomains, log) {
+        this.#cloudHandler = cloudHandler;
+        this.#projectDomains = projectDomains;
+        this.#log = log;
+    }
+    async #start(progress) {
+        const trashed = await ProjectStorage.loadTrashedIds();
+        const [uploadProgress, trashProgress, downloadProgress] = Progress.splitWithWeights(progress, [0.45, 0.10, 0.45]);
+        await this.#upload(uploadProgress);
+        await this.#trash(trashed, trashProgress);
+        await this.#download(trashed, downloadProgress);
+    }
+    async #upload(progress) {
+        const { local, cloud } = this.#projectDomains;
+        const isUnsynced = (localProject, cloudProject) => isAbsent(cloudProject)
+            || new Date(cloudProject.modified).getTime() < new Date(localProject.modified).getTime();
+        const unsyncedProjects = Object.entries(local)
+            .filter(([uuid, localProject]) => isUnsynced(localProject, cloud[uuid]))
+            .map(([uuid, localProject]) => ([UUID.asString(uuid), localProject]));
+        if (unsyncedProjects.length === 0) {
+            this.#log("No unsynced projects found.");
+            progress(1.0);
+            return;
+        }
+        const uploaded = await Promises.sequentialAll(unsyncedProjects
+            .map(([uuidAsString, meta], index, { length }) => async () => {
+            progress((index + 1) / length);
+            this.#log(`Uploading project '${meta.name}'`);
+            const uuid = UUID.parse(uuidAsString);
+            const folder = `${CloudBackupProjects.RemotePath}/${uuidAsString}`;
+            const metaFile = await ProjectStorage.loadMeta(uuid);
+            const projectFile = await ProjectStorage.loadProject(uuid);
+            const optCoverFile = await ProjectStorage.loadCover(uuid);
+            const tasks = [];
+            const removeProjectPath = `${folder}/project.od`;
+            const remoteMetaPath = `${folder}/meta.json`;
+            tasks.push(() => this.#cloudHandler.upload(removeProjectPath, projectFile));
+            tasks.push(() => this.#cloudHandler.upload(remoteMetaPath, metaFile));
+            optCoverFile.ifSome(cover => {
+                const removeCoverPath = `${folder}/image.bin`;
+                return tasks.push(() => this.#cloudHandler.upload(removeCoverPath, cover));
+            });
+            await Promises.approvedRetry(() => Promises.timeout(Promises.sequentialAll(tasks), TimeSpan.minutes(10), "Upload timeout (10 min)."), error => ({
+                headline: "Upload failed",
+                message: `Failed to upload project '${meta.name}'. '${error}'`,
+                approveText: "Retry",
+                cancelText: "Cancel"
+            }));
+            return { uuidAsString, meta };
+        }));
+        const catalog = uploaded
+            .reduce((projects, project) => {
+            projects[UUID.asString(project.uuidAsString)] = project.meta;
+            return projects;
+        }, { ...cloud });
+        await this.#uploadCatalog(catalog);
+        progress(1.0);
+    }
+    async #trash(trashed, progress) {
+        const { cloud } = this.#projectDomains;
+        const obsolete = Arrays.intersect(Object.entries(cloud), trashed, ([uuid, _], trashed) => uuid === trashed);
+        if (obsolete.length > 0) {
+            const approved = await RuntimeNotifier.approve({
+                headline: "Delete Projects?",
+                message: `Found ${obsolete.length} locally deleted projects. Delete from cloud as well?`,
+                approveText: "Yes",
+                cancelText: "No"
+            });
+            if (approved) {
+                const deleted = await Promises.sequentialAll(obsolete.map(([uuid, meta], index, { length }) => async () => {
+                    progress((index + 1) / length);
+                    const path = `${CloudBackupProjects.RemotePath}/${uuid}`;
+                    this.#log(`Deleting '${meta.name}'`);
+                    await this.#cloudHandler.delete(path);
+                    return UUID.asString(uuid);
+                }));
+                const catalog = { ...cloud };
+                deleted.forEach(uuid => delete catalog[uuid]);
+                await this.#uploadCatalog(catalog);
+            }
+        }
+        progress(1.0);
+    }
+    async #download(trashed, progress) {
+        const { cloud, local } = this.#projectDomains;
+        const compareFn = ([uuidA], [uuidB]) => uuidA === uuidB;
+        const missingLocally = Arrays.subtract(Object.entries(cloud), Object.entries(local), compareFn);
+        const download = Arrays.subtract(missingLocally, trashed, ([projectUUID], uuid) => projectUUID === uuid);
+        if (download.length === 0) {
+            this.#log("No projects to download.");
+            progress(1.0);
+            return;
+        }
+        await Promises.sequentialAll(download.map(([uuidAsString, meta], index, { length }) => async () => {
+            progress((index + 1) / length);
+            const uuid = UUID.parse(uuidAsString);
+            const path = `${CloudBackupProjects.RemotePath}/${uuidAsString}`;
+            this.#log(`Downloading project '${meta.name}'`);
+            const files = await Promises.guardedRetry(() => this.#cloudHandler.list(path), network.DefaultRetry);
+            const hasProjectFile = files.includes("project.od");
+            const hasMetaFile = files.includes("meta.json");
+            if (!hasProjectFile || !hasMetaFile) {
+                console.warn(`hasProjectFile: ${hasProjectFile}, hasMetaFile: ${hasMetaFile} for ${uuidAsString}`);
+                const approvedDeletion = await RuntimeNotifier.approve({
+                    headline: "Download failed",
+                    message: `Project '${meta.name}' is corrupted. Delete it from cloud?.`,
+                    approveText: "Yes",
+                    cancelText: "Ignore"
+                });
+                if (approvedDeletion) {
+                    await this.#cloudHandler.delete(path);
+                }
+                else {
+                    return uuidAsString;
+                }
+            }
+            const projectPath = `${path}/project.od`;
+            const metaPath = `${path}/meta.json`;
+            const coverPath = `${path}/image.bin`;
+            const projectArrayBuffer = await Promises.guardedRetry(() => this.#cloudHandler.download(projectPath), network.DefaultRetry);
+            const metaArrayBuffer = await Promises.guardedRetry(() => this.#cloudHandler.download(metaPath), network.DefaultRetry);
+            await WorkerAgents.Opfs.write(ProjectPaths.projectFile(uuid), new Uint8Array(projectArrayBuffer));
+            await WorkerAgents.Opfs.write(ProjectPaths.projectMeta(uuid), new Uint8Array(metaArrayBuffer));
+            const hasCover = files.some(file => file.endsWith("image.bin"));
+            if (hasCover) {
+                const arrayBuffer = await Promises.guardedRetry(() => this.#cloudHandler.download(coverPath), network.DefaultRetry);
+                await WorkerAgents.Opfs.write(ProjectPaths.projectCover(uuid), new Uint8Array(arrayBuffer));
+            }
+            return uuidAsString;
+        }));
+        this.#log("Download projects complete.");
+        progress(1.0);
+    }
+    async #uploadCatalog(catalog) {
+        this.#log("Uploading project catalog...");
+        const jsonString = JSON.stringify(catalog, null, 2);
+        const buffer = new TextEncoder().encode(jsonString).buffer;
+        return this.#cloudHandler.upload(CloudBackupProjects.RemoteCatalogPath, buffer);
+    }
+}

package/dist/clouds/CloudBackupSamples.d.ts

@@ -0,0 +1,13 @@
+import { Procedure, Progress, UUID } from "@opendaw/lib-std";
+import { Sample } from "@opendaw/studio-adapters";
+import { CloudHandler } from "./CloudHandler";
+export declare class CloudBackupSamples {
+    #private;
+    static readonly RemotePath = "samples";
+    static readonly RemoteCatalogPath: string;
+    static readonly areSamplesEqual: ({ uuid: a }: Sample, { uuid: b }: Sample) => boolean;
+    static pathFor(uuid: UUID.String): string;
+    static start(cloudHandler: CloudHandler, progress: Progress.Handler, log: Procedure<string>): Promise<void>;
+    private constructor();
+}
+//# sourceMappingURL=CloudBackupSamples.d.ts.map

package/dist/clouds/CloudBackupSamples.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CloudBackupSamples.d.ts","sourceRoot":"","sources":["../../src/clouds/CloudBackupSamples.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwB,SAAS,EAAE,QAAQ,EAAmB,IAAI,EAAC,MAAM,kBAAkB,CAAA;AAGlG,OAAO,EAAY,MAAM,EAAC,MAAM,0BAA0B,CAAA;AAG1D,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAA;AAM3C,qBAAa,kBAAkB;;IAC3B,MAAM,CAAC,QAAQ,CAAC,UAAU,aAAY;IACtC,MAAM,CAAC,QAAQ,CAAC,iBAAiB,SAAkC;IACnE,MAAM,CAAC,QAAQ,CAAC,eAAe,GAAI,aAAW,MAAM,EAAE,aAAW,MAAM,aAAY;IAEnF,MAAM,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,GAAG,MAAM;WAE5B,KAAK,CAAC,YAAY,EAAE,YAAY,EAC1B,QAAQ,EAAE,QAAQ,CAAC,OAAO,EAC1B,GAAG,EAAE,SAAS,CAAC,MAAM,CAAC;IAgBzC,OAAO;CAsHV"}

package/dist/clouds/CloudBackupSamples.js

@@ -0,0 +1,129 @@
+import { Arrays, Errors, panic, Progress, RuntimeNotifier, UUID } from "@opendaw/lib-std";
+import { network, Promises } from "@opendaw/lib-runtime";
+import { SamplePeaks } from "@opendaw/lib-fusion";
+import { OpenSampleAPI } from "../samples/OpenSampleAPI";
+import { SampleStorage } from "../samples/SampleStorage";
+import { WorkerAgents } from "../WorkerAgents";
+import { WavFile } from "../WavFile";
+export class CloudBackupSamples {
+    static RemotePath = "samples";
+    static RemoteCatalogPath = `${this.RemotePath}/index.json`;
+    static areSamplesEqual = ({ uuid: a }, { uuid: b }) => a === b;
+    static pathFor(uuid) { return `${this.RemotePath}/${uuid}.wav`; }
+    static async start(cloudHandler, progress, log) {
+        log("Collecting all sample domains...");
+        const [stock, local, cloud] = await Promise.all([
+            OpenSampleAPI.get().all(),
+            SampleStorage.listSamples(),
+            cloudHandler.download(CloudBackupSamples.RemoteCatalogPath)
+                .then(json => JSON.parse(new TextDecoder().decode(json)))
+                .catch(reason => reason instanceof Errors.FileNotFound ? Arrays.empty() : panic(reason))
+        ]);
+        return new CloudBackupSamples(cloudHandler, { stock, local, cloud }, log).#start(progress);
+    }
+    #cloudHandler;
+    #sampleDomains;
+    #log;
+    constructor(cloudHandler, sampleDomains, log) {
+        this.#cloudHandler = cloudHandler;
+        this.#sampleDomains = sampleDomains;
+        this.#log = log;
+    }
+    async #start(progress) {
+        const trashed = await SampleStorage.loadTrashedIds();
+        const [uploadProgress, trashProgress, downloadProgress] = Progress.splitWithWeights(progress, [0.45, 0.10, 0.45]);
+        await this.#upload(uploadProgress);
+        await this.#trash(trashed, trashProgress);
+        await this.#download(trashed, downloadProgress);
+    }
+    async #upload(progress) {
+        const { stock, local, cloud } = this.#sampleDomains;
+        const maybeUnsyncedSamples = Arrays.subtract(local, stock, CloudBackupSamples.areSamplesEqual);
+        const unsyncedSamples = Arrays.subtract(maybeUnsyncedSamples, cloud, CloudBackupSamples.areSamplesEqual);
+        if (unsyncedSamples.length === 0) {
+            this.#log("No unsynced samples found.");
+            progress(1.0);
+            return;
+        }
+        const uploadedSamples = await Promises.sequentialAll(unsyncedSamples.map((sample, index, { length }) => async () => {
+            progress((index + 1) / length);
+            this.#log(`Uploading sample '${sample.name}'`);
+            const arrayBuffer = await SampleStorage.loadSample(UUID.parse(sample.uuid))
+                .then(([{ frames: channels, numberOfChannels, numberOfFrames: numFrames, sampleRate }]) => WavFile.encodeFloats({ channels, numberOfChannels, numFrames, sampleRate }));
+            const path = CloudBackupSamples.pathFor(sample.uuid);
+            await Promises.approvedRetry(() => this.#cloudHandler.upload(path, arrayBuffer), error => ({
+                headline: "Upload failed",
+                message: `Failed to upload sample '${sample.name}'. '${error}'`,
+                approveText: "Retry",
+                cancelText: "Cancel"
+            }));
+            return sample;
+        }));
+        const catalog = Arrays.merge(cloud, uploadedSamples, CloudBackupSamples.areSamplesEqual);
+        await this.#uploadCatalog(catalog);
+        progress(1.0);
+    }
+    async #trash(trashed, progress) {
+        const { cloud } = this.#sampleDomains;
+        const obsolete = Arrays.intersect(cloud, trashed, (sample, uuid) => sample.uuid === uuid);
+        if (obsolete.length === 0) {
+            progress(1.0);
+            return;
+        }
+        const approved = await RuntimeNotifier.approve({
+            headline: "Delete Samples?",
+            message: `Found ${obsolete.length} locally deleted samples. Delete from cloud as well?`,
+            approveText: "Yes",
+            cancelText: "No"
+        });
+        if (!approved) {
+            progress(1.0);
+            return;
+        }
+        const result = await Promises.sequentialAll(obsolete.map((sample, index, { length }) => async () => {
+            progress((index + 1) / length);
+            this.#log(`Deleting '${sample.name}'`);
+            await this.#cloudHandler.delete(CloudBackupSamples.pathFor(sample.uuid));
+            return sample;
+        }));
+        const catalog = cloud.slice();
+        result.forEach((sample) => Arrays.removeIf(catalog, ({ uuid }) => sample.uuid === uuid));
+        await this.#uploadCatalog(catalog);
+        progress(1.0);
+    }
+    async #download(trashed, progress) {
+        const { cloud, local } = this.#sampleDomains;
+        const missingLocally = Arrays.subtract(cloud, local, CloudBackupSamples.areSamplesEqual);
+        const download = Arrays.subtract(missingLocally, trashed, (sample, uuid) => sample.uuid === uuid);
+        if (download.length === 0) {
+            this.#log("No samples to download.");
+            progress(1.0);
+            return;
+        }
+        await Promises.sequentialAll(download.map((sample, index, { length }) => async () => {
+            progress((index + 1) / length);
+            this.#log(`Downloading sample '${sample.name}'`);
+            const path = CloudBackupSamples.pathFor(sample.uuid);
+            const buffer = await Promises.guardedRetry(() => this.#cloudHandler.download(path), network.DefaultRetry);
+            const waveAudio = WavFile.decodeFloats(buffer);
+            const audioData = {
+                sampleRate: waveAudio.sampleRate,
+                numberOfFrames: waveAudio.numFrames,
+                numberOfChannels: waveAudio.channels.length,
+                frames: waveAudio.channels
+            };
+            const shifts = SamplePeaks.findBestFit(audioData.numberOfFrames);
+            const peaks = await WorkerAgents.Peak.generateAsync(Progress.Empty, shifts, audioData.frames, audioData.numberOfFrames, audioData.numberOfChannels);
+            await SampleStorage.saveSample(UUID.parse(sample.uuid), audioData, peaks, sample);
+            return sample;
+        }));
+        this.#log("Download samples complete.");
+        progress(1.0);
+    }
+    async #uploadCatalog(catalog) {
+        this.#log("Uploading sample catalog...");
+        const jsonString = JSON.stringify(catalog, null, 2);
+        const buffer = new TextEncoder().encode(jsonString).buffer;
+        return this.#cloudHandler.upload(CloudBackupSamples.RemoteCatalogPath, buffer);
+    }
+}

package/dist/clouds/CloudHandler.d.ts

@@ -0,0 +1,9 @@
+export interface CloudHandler {
+    upload(path: string, data: ArrayBuffer): Promise<void>;
+    exists(path: string): Promise<boolean>;
+    download(path: string): Promise<ArrayBuffer>;
+    list(path?: string): Promise<string[]>;
+    delete(path: string): Promise<void>;
+    alive(): Promise<void>;
+}
+//# sourceMappingURL=CloudHandler.d.ts.map

package/dist/clouds/CloudHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CloudHandler.d.ts","sourceRoot":"","sources":["../../src/clouds/CloudHandler.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,YAAY;IACzB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACtD,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IACtC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAAA;IAC5C,IAAI,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAA;IACtC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACnC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACzB"}

package/dist/clouds/CloudHandler.js

@@ -0,0 +1 @@
+export {};

package/dist/clouds/CloudService.d.ts

@@ -0,0 +1,2 @@
+export type CloudService = "Dropbox" | "GoogleDrive";
+//# sourceMappingURL=CloudService.d.ts.map

package/dist/clouds/CloudService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CloudService.d.ts","sourceRoot":"","sources":["../../src/clouds/CloudService.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,YAAY,GAAG,SAAS,GAAG,aAAa,CAAA"}

package/dist/clouds/CloudService.js

@@ -0,0 +1 @@
+export {};

package/dist/clouds/DropboxHandler.d.ts

@@ -0,0 +1,12 @@
+import { CloudHandler } from "./CloudHandler";
+export declare class DropboxHandler implements CloudHandler {
+    #private;
+    constructor(accessToken: string);
+    alive(): Promise<void>;
+    upload(path: string, buffer: ArrayBuffer): Promise<void>;
+    download(path: string): Promise<ArrayBuffer>;
+    exists(path: string): Promise<boolean>;
+    list(path?: string): Promise<Array<string>>;
+    delete(path: string): Promise<void>;
+}
+//# sourceMappingURL=DropboxHandler.d.ts.map

package/dist/clouds/DropboxHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DropboxHandler.d.ts","sourceRoot":"","sources":["../../src/clouds/DropboxHandler.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAA;AAI3C,qBAAa,cAAe,YAAW,YAAY;;gBAKnC,WAAW,EAAE,MAAM;IAEzB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAMtB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAaxD,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;IAe5C,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAWtC,IAAI,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IAO3C,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CA4B5C"}

package/dist/clouds/DropboxHandler.js

@@ -0,0 +1,83 @@
+import { DropboxResponseError } from "dropbox";
+import { Errors, isDefined, Option, panic } from "@opendaw/lib-std";
+import { Promises } from "@opendaw/lib-runtime";
+// written by ChatGPT
+export class DropboxHandler {
+    #accessToken;
+    #dropboxClient = Option.None;
+    constructor(accessToken) { this.#accessToken = accessToken; }
+    async alive() {
+        const client = await this.#ensureClient();
+        const { status, error } = await Promises.tryCatch(client.usersGetCurrentAccount());
+        if (status === "rejected")
+            return panic(error);
+    }
+    async upload(path, buffer) {
+        const client = await this.#ensureClient();
+        const fullPath = this.#getFullPath(path);
+        console.debug("[Dropbox] Uploading to:", fullPath);
+        const { status, error, value: result } = await Promises.tryCatch(client
+            .filesUpload({ path: fullPath, contents: buffer, mode: { ".tag": "overwrite" } }));
+        if (status === "rejected") {
+            return panic(error);
+        }
+        else {
+            console.debug("[Dropbox] Upload successful:", result.result.path_display);
+        }
+    }
+    async download(path) {
+        const client = await this.#ensureClient();
+        const fullPath = this.#getFullPath(path);
+        try {
+            const response = await client.filesDownload({ path: fullPath });
+            const { result: { fileBlob } } = response;
+            return fileBlob.arrayBuffer();
+        }
+        catch (error) {
+            if (this.#isNotFoundError(error)) {
+                throw new Errors.FileNotFound(path);
+            }
+            throw error;
+        }
+    }
+    async exists(path) {
+        const client = await this.#ensureClient();
+        const fullPath = this.#getFullPath(path);
+        const { status, error } = await Promises.tryCatch(client.filesGetMetadata({ path: fullPath })).catch(error => error);
+        if (status === "resolved")
+            return true;
+        return this.#isNotFoundError(error) ? false : panic(error);
+    }
+    async list(path) {
+        const client = await this.#ensureClient();
+        const fullPath = path ? this.#getFullPath(path) : "";
+        const response = await client.filesListFolder({ path: fullPath });
+        return response.result.entries.map(entry => entry.name).filter(isDefined);
+    }
+    async delete(path) {
+        const client = await this.#ensureClient();
+        const fullPath = this.#getFullPath(path);
+        await client.filesDeleteV2({ path: fullPath });
+    }
+    async #ensureClient() {
+        if (this.#dropboxClient.isEmpty()) {
+            const DropboxModule = await import("dropbox");
+            this.#dropboxClient = Option.wrap(new DropboxModule.Dropbox({ accessToken: this.#accessToken }));
+        }
+        return this.#dropboxClient.unwrap();
+    }
+    #getFullPath(path) {
+        if (path.includes(":") || path.includes("T")) {
+            const filename = path.replace(/:/g, "-");
+            return filename.startsWith("/") ? filename : `/${filename}`;
+        }
+        return path.startsWith("/") ? path : `/${path}`;
+    }
+    #isNotFoundError(error) {
+        if (!(error instanceof DropboxResponseError))
+            return false;
+        const e = error.error;
+        return e?.error?.[".tag"] === "path" &&
+            e.error?.path?.[".tag"] === "not_found";
+    }
+}

package/dist/clouds/GoogleDriveHandler.d.ts

@@ -0,0 +1,12 @@
+import { CloudHandler } from "./CloudHandler";
+export declare class GoogleDriveHandler implements CloudHandler {
+    #private;
+    constructor(accessToken: string);
+    alive(): Promise<void>;
+    upload(path: string, data: ArrayBuffer): Promise<void>;
+    download(path: string): Promise<ArrayBuffer>;
+    exists(path: string): Promise<boolean>;
+    list(path?: string): Promise<string[]>;
+    delete(path: string): Promise<void>;
+}
+//# sourceMappingURL=GoogleDriveHandler.d.ts.map

package/dist/clouds/GoogleDriveHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GoogleDriveHandler.d.ts","sourceRoot":"","sources":["../../src/clouds/GoogleDriveHandler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAA;AAmB3C,qBAAa,kBAAmB,YAAW,YAAY;;gBAKvC,WAAW,EAAE,MAAM;IAEzB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IActB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IA8BtD,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;IAe5C,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAKtC,IAAI,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IA4BtC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAmK5C"}