zitejs 0.9.54 → 0.9.55

package/dist/cjs/internal/sdkCall.d.ts

@@ -0,0 +1,2 @@
+export type SdkCall = (integrationId: string, className: string, methodName: string, params?: unknown) => Promise<unknown>;
+export declare function getSdkCall(): SdkCall;

package/dist/cjs/internal/sdkCall.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSdkCall = getSdkCall;
+function getSdkCall() {
+    const fn = globalThis.__wrapSdkCall;
+    if (!fn) {
+        throw new Error('Zite SDK runtime not initialized. Endpoints must run inside the Zite worker.');
+    }
+    return fn;
+}

package/dist/cjs/pdf/index.d.ts

@@ -1,9 +1,12 @@
+export interface RenderHtmlParams {
+    html: string;
+    filename?: string;
+}
+export interface RenderHtmlResult {
+    url: string;
+    filename: string;
+}
 export declare class ZitePdf {
-    generate(options: {
-        html: string;
-        [key: string]: unknown;
-    }): Promise<{
-        url: string;
-        [key: string]: unknown;
-    }>;
+    static renderHtml(params: RenderHtmlParams): Promise<RenderHtmlResult>;
 }
+export declare const Pdf: typeof ZitePdf;

package/dist/cjs/pdf/index.js

@@ -1,9 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZitePdf = void 0;
+exports.Pdf = exports.ZitePdf = void 0;
+const sdkCall_js_1 = require("../internal/sdkCall.js");
+const PDF_LIB_INTEGRATION_ID = '__pdf__';
 class ZitePdf {
-    generate(options) {
-        throw new Error('ZitePdf is only available in the Zite runtime.');
+    static renderHtml(params) {
+        return (0, sdkCall_js_1.getSdkCall)()(PDF_LIB_INTEGRATION_ID, 'ZitePdf', 'renderHtml', params);
     }
 }
 exports.ZitePdf = ZitePdf;
+exports.Pdf = ZitePdf;

package/dist/cjs/runtime/index.js

@@ -4,13 +4,7 @@ exports.createCaller = void 0;
 exports.createTableClient = createTableClient;
 exports.createSqlClient = createSqlClient;
 exports.createAirtableClient = createAirtableClient;
-function getSdkCall() {
-    const fn = globalThis.__wrapSdkCall;
-    if (!fn) {
-        throw new Error("Zite SDK runtime not initialized. Endpoints must run inside the Zite worker.");
-    }
-    return fn;
-}
+const sdkCall_js_1 = require("../internal/sdkCall.js");
 const DB_INTEGRATION_ID = "databases";
 function getBaseId() {
     try {
@@ -38,33 +32,33 @@ function resolveTableId(className) {
 }
 function createTableClient(className) {
     return {
-        findAll: (options) => getSdkCall()(DB_INTEGRATION_ID, className, "findAll", {
+        findAll: (options) => (0, sdkCall_js_1.getSdkCall)()(DB_INTEGRATION_ID, className, "findAll", {
             baseId: getBaseId(),
             tableId: resolveTableId(className),
             ...options,
         }),
-        findOne: (recordId) => getSdkCall()(DB_INTEGRATION_ID, className, "findOne", {
+        findOne: (recordId) => (0, sdkCall_js_1.getSdkCall)()(DB_INTEGRATION_ID, className, "findOne", {
             baseId: getBaseId(),
             tableId: resolveTableId(className),
             ...(typeof recordId === "string" ? { id: recordId } : recordId),
         }),
-        create: (data) => getSdkCall()(DB_INTEGRATION_ID, className, "create", {
+        create: (data) => (0, sdkCall_js_1.getSdkCall)()(DB_INTEGRATION_ID, className, "create", {
             baseId: getBaseId(),
             tableId: resolveTableId(className),
             ...data,
         }),
-        update: (id, data) => getSdkCall()(DB_INTEGRATION_ID, className, "update", {
+        update: (id, data) => (0, sdkCall_js_1.getSdkCall)()(DB_INTEGRATION_ID, className, "update", {
             baseId: getBaseId(),
             tableId: resolveTableId(className),
             id,
             ...data,
         }),
-        delete: (id) => getSdkCall()(DB_INTEGRATION_ID, className, "delete", {
+        delete: (id) => (0, sdkCall_js_1.getSdkCall)()(DB_INTEGRATION_ID, className, "delete", {
             baseId: getBaseId(),
             tableId: resolveTableId(className),
             id,
         }),
-        bulkCreate: (records) => getSdkCall()(DB_INTEGRATION_ID, className, "bulkCreate", {
+        bulkCreate: (records) => (0, sdkCall_js_1.getSdkCall)()(DB_INTEGRATION_ID, className, "bulkCreate", {
             baseId: getBaseId(),
             tableId: resolveTableId(className),
             records,
@@ -72,35 +66,35 @@ function createTableClient(className) {
     };
 }
 function createSqlClient() {
-    return (params) => getSdkCall()(DB_INTEGRATION_ID, "Db", "executeSql", {
+    return (params) => (0, sdkCall_js_1.getSdkCall)()(DB_INTEGRATION_ID, "Db", "executeSql", {
         baseId: getBaseId(),
         ...params,
     });
 }
 function createAirtableClient(integrationId, className, implicitParams) {
     return {
-        findAll: (options) => getSdkCall()(integrationId, className, "findAll", {
+        findAll: (options) => (0, sdkCall_js_1.getSdkCall)()(integrationId, className, "findAll", {
             ...implicitParams,
             ...options,
         }),
-        findOne: (params) => getSdkCall()(integrationId, className, "findOne", {
+        findOne: (params) => (0, sdkCall_js_1.getSdkCall)()(integrationId, className, "findOne", {
             ...implicitParams,
             ...params,
         }),
-        create: (data) => getSdkCall()(integrationId, className, "create", {
+        create: (data) => (0, sdkCall_js_1.getSdkCall)()(integrationId, className, "create", {
             ...implicitParams,
             ...data,
         }),
-        bulkCreate: (records) => getSdkCall()(integrationId, className, "bulkCreate", {
+        bulkCreate: (records) => (0, sdkCall_js_1.getSdkCall)()(integrationId, className, "bulkCreate", {
             ...implicitParams,
             records,
         }),
-        update: (id, data) => getSdkCall()(integrationId, className, "update", {
+        update: (id, data) => (0, sdkCall_js_1.getSdkCall)()(integrationId, className, "update", {
             ...implicitParams,
             id,
             ...data,
         }),
-        delete: (id) => getSdkCall()(integrationId, className, "delete", {
+        delete: (id) => (0, sdkCall_js_1.getSdkCall)()(integrationId, className, "delete", {
             ...implicitParams,
             id,
         }),

package/dist/cjs/schedules/index.d.ts

@@ -1,16 +1,106 @@
-export declare class ZiteSchedule {
-    static create(config: {
-        name: string;
-        cron: string;
-        endpoint: string;
-        input?: Record<string, unknown>;
+type DayOfWeek = 'sun' | 'mon' | 'tue' | 'wed' | 'thu' | 'fri' | 'sat';
+type ActiveWindow = {
+    hoursRange?: {
+        from: string;
+        to: string;
+    };
+    daysOfWeek?: DayOfWeek[];
+};
+export type ZiteSchedule = {
+    scheduleType: 'recurring';
+    schedule: {
+        frequency: 'minutely';
+        interval: number;
+        activeWindow?: ActiveWindow;
+    } | {
+        frequency: 'hourly';
+        interval: number;
+        minute?: number;
+        activeWindow?: ActiveWindow;
+    } | {
+        frequency: 'daily';
+        interval: number;
+        times: string[];
+    } | {
+        frequency: 'weekly';
+        interval: number;
+        daysOfWeek: DayOfWeek[];
+        times: string[];
+    } | {
+        frequency: 'monthly';
+        interval: 1;
+        monthlyDay: {
+            type: 'dayOfMonth';
+            day: number | 'last';
+        } | {
+            type: 'weekdayOccurrence';
+            weekday: DayOfWeek;
+            occurrence: 1 | 2 | 3 | 4 | 'last';
+        };
+        times: string[];
+    };
+    endPolicy?: {
+        type: 'never';
+    } | {
+        type: 'onDate';
+        endAt: string;
+    } | {
+        type: 'afterOccurrences';
+        occurrences: number;
+    };
+    overlapPolicy?: 'skip' | 'allow';
+    timezone: string;
+    paused?: boolean;
+} | {
+    scheduleType: 'oneTime';
+    fireAt: string;
+    timezone: string;
+    paused?: boolean;
+};
+export type Schedule = ZiteSchedule;
+export type RuntimeScheduleInfo = {
+    id: string;
+    cronJobId: string;
+    endpointId: string;
+    schedule: ZiteSchedule | null;
+    inputs?: Record<string, unknown>;
+    paused: boolean;
+    nextActionTimes: string[];
+    recentActions: {
+        scheduledAt: string;
+        takenAt: string;
+        workflowId: string;
+        firstExecutionRunId: string;
+    }[];
+};
+export declare class ZiteSchedules {
+    static add(args: {
+        endpointId: string;
+        schedule: ZiteSchedule;
+        inputs?: Record<string, unknown>;
     }): Promise<{
         id: string;
+        cronJobId: string;
     }>;
-    static delete(id: string): Promise<void>;
-    static list(): Promise<Array<{
+    static list(args?: {
+        endpointId?: string;
+    }): Promise<{
+        schedules: RuntimeScheduleInfo[];
+    }>;
+    static remove(args: {
         id: string;
-        name: string;
-        cron: string;
-    }>>;
+    }): Promise<{
+        id: string;
+        deleted: true;
+    }>;
+    static update(args: {
+        id: string;
+        schedule?: ZiteSchedule;
+        inputs?: Record<string, unknown>;
+    }): Promise<{
+        id: string;
+        updated: true;
+    }>;
 }
+export declare const Schedules: typeof ZiteSchedules;
+export {};

package/dist/cjs/schedules/index.js

@@ -1,15 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZiteSchedule = void 0;
-class ZiteSchedule {
-    static create(config) {
-        throw new Error('ZiteSchedule is only available in the Zite runtime.');
+exports.Schedules = exports.ZiteSchedules = void 0;
+const sdkCall_js_1 = require("../internal/sdkCall.js");
+const SCHEDULES_SDK_INTEGRATION_ID = '__schedules__';
+class ZiteSchedules {
+    static add(args) {
+        return (0, sdkCall_js_1.getSdkCall)()(SCHEDULES_SDK_INTEGRATION_ID, 'ZiteSchedules', 'add', args);
     }
-    static delete(id) {
-        throw new Error('ZiteSchedule is only available in the Zite runtime.');
+    static list(args) {
+        return (0, sdkCall_js_1.getSdkCall)()(SCHEDULES_SDK_INTEGRATION_ID, 'ZiteSchedules', 'list', args ?? {});
     }
-    static list() {
-        throw new Error('ZiteSchedule is only available in the Zite runtime.');
+    static remove(args) {
+        return (0, sdkCall_js_1.getSdkCall)()(SCHEDULES_SDK_INTEGRATION_ID, 'ZiteSchedules', 'remove', args);
+    }
+    static update(args) {
+        return (0, sdkCall_js_1.getSdkCall)()(SCHEDULES_SDK_INTEGRATION_ID, 'ZiteSchedules', 'update', args);
     }
 }
-exports.ZiteSchedule = ZiteSchedule;
+exports.ZiteSchedules = ZiteSchedules;
+exports.Schedules = ZiteSchedules;

package/dist/cjs/upload/index.d.ts

@@ -1,5 +1,15 @@
+export type UploadData = string | Blob | ArrayBuffer | File;
+export declare class FileUploadError extends Error {
+    constructor(message: string);
+}
+export declare function uploadFile({ data, filename, }: {
+    data: UploadData;
+    filename: string;
+}): Promise<{
+    fileUrl: string;
+}>;
 export declare function useUpload(): {
-    upload: (file: File) => Promise<{
+    upload: (file: File | Blob | ArrayBuffer | string, filename?: string) => Promise<{
         url: string;
     }>;
     isUploading: boolean;

package/dist/cjs/upload/index.js

@@ -1,6 +1,112 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileUploadError = void 0;
+exports.uploadFile = uploadFile;
 exports.useUpload = useUpload;
+const react_1 = require("react");
+const config_js_1 = require("../auth/config.js");
+const constants_js_1 = require("../auth/constants.js");
+class FileUploadError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'FileUploadError';
+    }
+}
+exports.FileUploadError = FileUploadError;
+function getZiteAppMode(hostname) {
+    const maybeId = hostname.split('.')[0];
+    if (maybeId?.startsWith(constants_js_1.ZITE_APP_EDITOR_HOSTNAME_PREFIX))
+        return 'preview';
+    if (maybeId?.startsWith(constants_js_1.ZITE_APP_ACTION_HOSTNAME_PREFIX))
+        return 'preview';
+    if (constants_js_1.ZITE_SANDBOX_DOMAINS.some(d => hostname === d || hostname.endsWith('.' + d))) {
+        return 'preview';
+    }
+    return 'live';
+}
+function readBlobAsDataUrl(blob) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = () => resolve(reader.result);
+        reader.onerror = () => reject(reader.error ?? new Error('Failed to read file'));
+        reader.readAsDataURL(blob);
+    });
+}
+async function toDataUrl(data) {
+    if (data instanceof Blob) {
+        return readBlobAsDataUrl(data);
+    }
+    if (data instanceof ArrayBuffer) {
+        const bytes = new Uint8Array(data);
+        let binary = '';
+        for (let i = 0; i < bytes.byteLength; i++) {
+            binary += String.fromCharCode(bytes[i]);
+        }
+        return 'data:application/octet-stream;base64,' + btoa(binary);
+    }
+    if (typeof data === 'string') {
+        if (data.startsWith('data:'))
+            return data;
+        if (/^[A-Za-z0-9+/]+=*$/.test(data)) {
+            return 'data:application/octet-stream;base64,' + data;
+        }
+        return 'data:text/plain;base64,' + btoa(unescape(encodeURIComponent(data)));
+    }
+    throw new FileUploadError('Invalid data format. Expected string, Blob, ArrayBuffer, or File.');
+}
+function resolveFilename(data, filename) {
+    if (filename)
+        return filename;
+    if (typeof File !== 'undefined' && data instanceof File && data.name) {
+        return data.name;
+    }
+    throw new FileUploadError('A filename is required unless the uploaded data is a File.');
+}
+async function performUpload(data, filename) {
+    const body = await toDataUrl(data);
+    const mode = getZiteAppMode(window.location.hostname);
+    const flowId = (0, config_js_1.getFlowId)();
+    const token = typeof localStorage !== 'undefined'
+        ? localStorage.getItem('zite.auth.token')
+        : null;
+    const res = await fetch((0, config_js_1.getApiUrl)() + '/v1/zite/public/' + flowId + '/upload?mode=' + mode, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            ...(token ? { Authorization: 'Bearer ' + token } : {}),
+        },
+        body: JSON.stringify({ data: body, filename }),
+    });
+    if (!res.ok) {
+        let message = 'Upload failed';
+        try {
+            const err = (await res.json());
+            if (err.message)
+                message = err.message;
+        }
+        catch { }
+        throw new FileUploadError(message);
+    }
+    const result = (await res.json());
+    if (!result.success || !result.fileUrl) {
+        throw new FileUploadError(result.message ?? 'Upload failed');
+    }
+    return result.fileUrl;
+}
+async function uploadFile({ data, filename, }) {
+    return { fileUrl: await performUpload(data, filename) };
+}
 function useUpload() {
-    throw new Error('useUpload() is only available in the Zite runtime.');
+    const [isUploading, setIsUploading] = (0, react_1.useState)(false);
+    const upload = (0, react_1.useCallback)(async (file, filename) => {
+        setIsUploading(true);
+        try {
+            const url = await performUpload(file, resolveFilename(file, filename));
+            return { url };
+        }
+        finally {
+            setIsUploading(false);
+        }
+    }, []);
+    return { upload, isUploading };
 }

package/dist/esm/internal/sdkCall.d.ts

@@ -0,0 +1,2 @@
+export type SdkCall = (integrationId: string, className: string, methodName: string, params?: unknown) => Promise<unknown>;
+export declare function getSdkCall(): SdkCall;

package/dist/esm/internal/sdkCall.js

@@ -0,0 +1,7 @@
+export function getSdkCall() {
+    const fn = globalThis.__wrapSdkCall;
+    if (!fn) {
+        throw new Error('Zite SDK runtime not initialized. Endpoints must run inside the Zite worker.');
+    }
+    return fn;
+}

package/dist/esm/pdf/index.d.ts

@@ -1,9 +1,12 @@
+export interface RenderHtmlParams {
+    html: string;
+    filename?: string;
+}
+export interface RenderHtmlResult {
+    url: string;
+    filename: string;
+}
 export declare class ZitePdf {
-    generate(options: {
-        html: string;
-        [key: string]: unknown;
-    }): Promise<{
-        url: string;
-        [key: string]: unknown;
-    }>;
+    static renderHtml(params: RenderHtmlParams): Promise<RenderHtmlResult>;
 }
+export declare const Pdf: typeof ZitePdf;

package/dist/esm/pdf/index.js

@@ -1,5 +1,8 @@
+import { getSdkCall } from '../internal/sdkCall.js';
+const PDF_LIB_INTEGRATION_ID = '__pdf__';
 export class ZitePdf {
-    generate(options) {
-        throw new Error('ZitePdf is only available in the Zite runtime.');
+    static renderHtml(params) {
+        return getSdkCall()(PDF_LIB_INTEGRATION_ID, 'ZitePdf', 'renderHtml', params);
     }
 }
+export const Pdf = ZitePdf;

package/dist/esm/runtime/index.js

@@ -1,10 +1,4 @@
-function getSdkCall() {
-    const fn = globalThis.__wrapSdkCall;
-    if (!fn) {
-        throw new Error("Zite SDK runtime not initialized. Endpoints must run inside the Zite worker.");
-    }
-    return fn;
-}
+import { getSdkCall } from "../internal/sdkCall.js";
 const DB_INTEGRATION_ID = "databases";
 function getBaseId() {
     try {

package/dist/esm/schedules/index.d.ts

@@ -1,16 +1,106 @@
-export declare class ZiteSchedule {
-    static create(config: {
-        name: string;
-        cron: string;
-        endpoint: string;
-        input?: Record<string, unknown>;
+type DayOfWeek = 'sun' | 'mon' | 'tue' | 'wed' | 'thu' | 'fri' | 'sat';
+type ActiveWindow = {
+    hoursRange?: {
+        from: string;
+        to: string;
+    };
+    daysOfWeek?: DayOfWeek[];
+};
+export type ZiteSchedule = {
+    scheduleType: 'recurring';
+    schedule: {
+        frequency: 'minutely';
+        interval: number;
+        activeWindow?: ActiveWindow;
+    } | {
+        frequency: 'hourly';
+        interval: number;
+        minute?: number;
+        activeWindow?: ActiveWindow;
+    } | {
+        frequency: 'daily';
+        interval: number;
+        times: string[];
+    } | {
+        frequency: 'weekly';
+        interval: number;
+        daysOfWeek: DayOfWeek[];
+        times: string[];
+    } | {
+        frequency: 'monthly';
+        interval: 1;
+        monthlyDay: {
+            type: 'dayOfMonth';
+            day: number | 'last';
+        } | {
+            type: 'weekdayOccurrence';
+            weekday: DayOfWeek;
+            occurrence: 1 | 2 | 3 | 4 | 'last';
+        };
+        times: string[];
+    };
+    endPolicy?: {
+        type: 'never';
+    } | {
+        type: 'onDate';
+        endAt: string;
+    } | {
+        type: 'afterOccurrences';
+        occurrences: number;
+    };
+    overlapPolicy?: 'skip' | 'allow';
+    timezone: string;
+    paused?: boolean;
+} | {
+    scheduleType: 'oneTime';
+    fireAt: string;
+    timezone: string;
+    paused?: boolean;
+};
+export type Schedule = ZiteSchedule;
+export type RuntimeScheduleInfo = {
+    id: string;
+    cronJobId: string;
+    endpointId: string;
+    schedule: ZiteSchedule | null;
+    inputs?: Record<string, unknown>;
+    paused: boolean;
+    nextActionTimes: string[];
+    recentActions: {
+        scheduledAt: string;
+        takenAt: string;
+        workflowId: string;
+        firstExecutionRunId: string;
+    }[];
+};
+export declare class ZiteSchedules {
+    static add(args: {
+        endpointId: string;
+        schedule: ZiteSchedule;
+        inputs?: Record<string, unknown>;
     }): Promise<{
         id: string;
+        cronJobId: string;
     }>;
-    static delete(id: string): Promise<void>;
-    static list(): Promise<Array<{
+    static list(args?: {
+        endpointId?: string;
+    }): Promise<{
+        schedules: RuntimeScheduleInfo[];
+    }>;
+    static remove(args: {
         id: string;
-        name: string;
-        cron: string;
-    }>>;
+    }): Promise<{
+        id: string;
+        deleted: true;
+    }>;
+    static update(args: {
+        id: string;
+        schedule?: ZiteSchedule;
+        inputs?: Record<string, unknown>;
+    }): Promise<{
+        id: string;
+        updated: true;
+    }>;
 }
+export declare const Schedules: typeof ZiteSchedules;
+export {};

package/dist/esm/schedules/index.js

@@ -1,11 +1,17 @@
-export class ZiteSchedule {
-    static create(config) {
-        throw new Error('ZiteSchedule is only available in the Zite runtime.');
+import { getSdkCall } from '../internal/sdkCall.js';
+const SCHEDULES_SDK_INTEGRATION_ID = '__schedules__';
+export class ZiteSchedules {
+    static add(args) {
+        return getSdkCall()(SCHEDULES_SDK_INTEGRATION_ID, 'ZiteSchedules', 'add', args);
     }
-    static delete(id) {
-        throw new Error('ZiteSchedule is only available in the Zite runtime.');
+    static list(args) {
+        return getSdkCall()(SCHEDULES_SDK_INTEGRATION_ID, 'ZiteSchedules', 'list', args ?? {});
     }
-    static list() {
-        throw new Error('ZiteSchedule is only available in the Zite runtime.');
+    static remove(args) {
+        return getSdkCall()(SCHEDULES_SDK_INTEGRATION_ID, 'ZiteSchedules', 'remove', args);
+    }
+    static update(args) {
+        return getSdkCall()(SCHEDULES_SDK_INTEGRATION_ID, 'ZiteSchedules', 'update', args);
     }
 }
+export const Schedules = ZiteSchedules;

package/dist/esm/upload/index.d.ts

@@ -1,5 +1,15 @@
+export type UploadData = string | Blob | ArrayBuffer | File;
+export declare class FileUploadError extends Error {
+    constructor(message: string);
+}
+export declare function uploadFile({ data, filename, }: {
+    data: UploadData;
+    filename: string;
+}): Promise<{
+    fileUrl: string;
+}>;
 export declare function useUpload(): {
-    upload: (file: File) => Promise<{
+    upload: (file: File | Blob | ArrayBuffer | string, filename?: string) => Promise<{
         url: string;
     }>;
     isUploading: boolean;

package/dist/esm/upload/index.js

@@ -1,3 +1,106 @@
+import { useCallback, useState } from 'react';
+import { getApiUrl, getFlowId } from '../auth/config.js';
+import { ZITE_APP_ACTION_HOSTNAME_PREFIX, ZITE_APP_EDITOR_HOSTNAME_PREFIX, ZITE_SANDBOX_DOMAINS, } from '../auth/constants.js';
+export class FileUploadError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'FileUploadError';
+    }
+}
+function getZiteAppMode(hostname) {
+    const maybeId = hostname.split('.')[0];
+    if (maybeId?.startsWith(ZITE_APP_EDITOR_HOSTNAME_PREFIX))
+        return 'preview';
+    if (maybeId?.startsWith(ZITE_APP_ACTION_HOSTNAME_PREFIX))
+        return 'preview';
+    if (ZITE_SANDBOX_DOMAINS.some(d => hostname === d || hostname.endsWith('.' + d))) {
+        return 'preview';
+    }
+    return 'live';
+}
+function readBlobAsDataUrl(blob) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = () => resolve(reader.result);
+        reader.onerror = () => reject(reader.error ?? new Error('Failed to read file'));
+        reader.readAsDataURL(blob);
+    });
+}
+async function toDataUrl(data) {
+    if (data instanceof Blob) {
+        return readBlobAsDataUrl(data);
+    }
+    if (data instanceof ArrayBuffer) {
+        const bytes = new Uint8Array(data);
+        let binary = '';
+        for (let i = 0; i < bytes.byteLength; i++) {
+            binary += String.fromCharCode(bytes[i]);
+        }
+        return 'data:application/octet-stream;base64,' + btoa(binary);
+    }
+    if (typeof data === 'string') {
+        if (data.startsWith('data:'))
+            return data;
+        if (/^[A-Za-z0-9+/]+=*$/.test(data)) {
+            return 'data:application/octet-stream;base64,' + data;
+        }
+        return 'data:text/plain;base64,' + btoa(unescape(encodeURIComponent(data)));
+    }
+    throw new FileUploadError('Invalid data format. Expected string, Blob, ArrayBuffer, or File.');
+}
+function resolveFilename(data, filename) {
+    if (filename)
+        return filename;
+    if (typeof File !== 'undefined' && data instanceof File && data.name) {
+        return data.name;
+    }
+    throw new FileUploadError('A filename is required unless the uploaded data is a File.');
+}
+async function performUpload(data, filename) {
+    const body = await toDataUrl(data);
+    const mode = getZiteAppMode(window.location.hostname);
+    const flowId = getFlowId();
+    const token = typeof localStorage !== 'undefined'
+        ? localStorage.getItem('zite.auth.token')
+        : null;
+    const res = await fetch(getApiUrl() + '/v1/zite/public/' + flowId + '/upload?mode=' + mode, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            ...(token ? { Authorization: 'Bearer ' + token } : {}),
+        },
+        body: JSON.stringify({ data: body, filename }),
+    });
+    if (!res.ok) {
+        let message = 'Upload failed';
+        try {
+            const err = (await res.json());
+            if (err.message)
+                message = err.message;
+        }
+        catch { }
+        throw new FileUploadError(message);
+    }
+    const result = (await res.json());
+    if (!result.success || !result.fileUrl) {
+        throw new FileUploadError(result.message ?? 'Upload failed');
+    }
+    return result.fileUrl;
+}
+export async function uploadFile({ data, filename, }) {
+    return { fileUrl: await performUpload(data, filename) };
+}
 export function useUpload() {
-    throw new Error('useUpload() is only available in the Zite runtime.');
+    const [isUploading, setIsUploading] = useState(false);
+    const upload = useCallback(async (file, filename) => {
+        setIsUploading(true);
+        try {
+            const url = await performUpload(file, resolveFilename(file, filename));
+            return { url };
+        }
+        finally {
+            setIsUploading(false);
+        }
+    }, []);
+    return { upload, isUploading };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zitejs",
-  "version": "0.9.54",
+  "version": "0.9.55",
   "description": "The Zite framework — build apps on Zite Database",
   "type": "module",
   "main": "./dist/cjs/index.js",

package/dist/cjs/api/index.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createCaller = void 0;
-var index_js_1 = require("../caller/index.js");
-Object.defineProperty(exports, "createCaller", { enumerable: true, get: function () { return index_js_1.createCaller; } });

package/dist/cjs/db/index.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createTableClient = void 0;
-var index_js_1 = require("../runtime/index.js");
-Object.defineProperty(exports, "createTableClient", { enumerable: true, get: function () { return index_js_1.createTableClient; } });

package/dist/esm/api/index.d.ts

@@ -1,2 +0,0 @@
-export { createCaller } from '../caller/index.js';
-export type { EndpointConfig } from '../caller/index.js';

package/dist/esm/api/index.js

@@ -1 +0,0 @@
-export { createCaller } from '../caller/index.js';

package/dist/esm/db/index.d.ts

@@ -1,2 +0,0 @@
-export { createTableClient } from '../runtime/index.js';
-export type { TableClient } from '../runtime/index.js';

package/dist/esm/db/index.js

@@ -1 +0,0 @@
-export { createTableClient } from '../runtime/index.js';