@embeddable.com/sdk-core 1.0.0 → 2.0.1

package/lib/index.esm.js

@@ -1,148 +1,848 @@
-var normalizeEntities = function (entities, _a) {
-    var _b = _a.mapFn, mapFn = _b === void 0 ? function (x) { return x; } : _b, _c = _a.filterFn, filterFn = _c === void 0 ? Boolean : _c;
-    if (!entities)
-        return undefined;
-    var filtered = entities.filter(filterFn);
-    if (filtered.length === 0)
-        return undefined;
-    return filtered.map(mapFn);
-};
-var getName = function (x) { return x.name; };
-var validateOrderBy = function (orderByParam, dimensions, measures) {
-    var unknownDimensionsOrMeasures = [];
-    var dimensionAndMeasureNames = measures
-        .concat(dimensions)
-        .map(function (x) { return x.name; });
-    for (var _i = 0, orderByParam_1 = orderByParam; _i < orderByParam_1.length; _i++) {
-        var orderBy = orderByParam_1[_i];
-        var name_1 = orderBy.property.name;
-        if (dimensionAndMeasureNames.includes(name_1))
+import * as fs from 'node:fs/promises';
+import { readdir, lstat } from 'node:fs/promises';
+import * as path from 'node:path';
+import { join } from 'node:path';
+import * as vite from 'vite';
+import 'node:child_process';
+import * as fsSync from 'node:fs';
+import { createNodeLogger, createNodeSys } from '@stencil/core/sys/node';
+import { loadConfig, createCompiler } from '@stencil/core/compiler';
+import * as YAML from 'yaml';
+import * as os from 'node:os';
+import axios from 'axios';
+import * as archiver from 'archiver';
+import { createReadStream } from 'fs';
+import { stat } from 'fs/promises';
+import { basename } from 'path';
+
+var findFiles = async (initialSrcDir, regex) => {
+    const filesList = [];
+    async function findFilesRec(srcDir) {
+        const allFiles = await readdir(srcDir);
+        for (const file of allFiles) {
+            const filePath = join(srcDir, file);
+            const status = await lstat(filePath);
+            if (status.isDirectory()) {
+                await findFilesRec(filePath);
+            }
+            const fileName = file.match(regex);
+            if (fileName) {
+                filesList.push([fileName[1], filePath]);
+            }
+        }
+    }
+    await findFilesRec(initialSrcDir);
+    return filesList;
+};
+
+const oraP$2 = import('ora');
+const EMB_TYPE_FILE_REGEX = /^(.*)\.type\.emb\.[jt]s$/;
+const EMB_OPTIONS_FILE_REGEX = /^(.*)\.options\.emb\.[jt]s$/;
+var buildTypes = async (ctx) => {
+    const ora = (await oraP$2).default;
+    const progress = ora("building types...").start();
+    await generate$1(ctx);
+    await build$1(ctx);
+    await cleanup$1(ctx);
+    progress.succeed("types built completed");
+};
+async function generate$1(ctx) {
+    const typeFiles = await findFiles(ctx.client.srcDir, EMB_TYPE_FILE_REGEX);
+    const optionsFiles = await findFiles(ctx.client.srcDir, EMB_OPTIONS_FILE_REGEX);
+    const typeImports = typeFiles
+        .concat(optionsFiles)
+        .map(([_fileName, filePath]) => `import './${path.relative(ctx.client.rootDir, filePath)}';`)
+        .join("\n");
+    await fs.writeFile(path.resolve(ctx.client.rootDir, ctx.outputOptions.typesEntryPointFilename), typeImports);
+}
+async function build$1(ctx) {
+    process.chdir(ctx.client.rootDir);
+    await vite.build({
+        logLevel: "error",
+        build: {
+            emptyOutDir: false,
+            lib: {
+                entry: `./${ctx.outputOptions.typesEntryPointFilename}`,
+                formats: ["es"],
+                fileName: "embeddable-types",
+            },
+            outDir: ".embeddable-build/",
+        },
+    });
+}
+async function cleanup$1(ctx) {
+    await fs.rm(path.resolve(ctx.client.rootDir, "embeddable-types-entry-point.js"));
+}
+
+var prepare = async (ctx) => {
+    await removeIfExists(ctx);
+    await copyStencilConfigsToClient(ctx);
+    await createComponentDir(ctx.client.componentDir);
+};
+async function removeIfExists(ctx) {
+    if (fsSync.existsSync(ctx.client.buildDir))
+        await fs.rm(ctx.client.buildDir, { recursive: true });
+}
+async function copyStencilConfigsToClient(ctx) {
+    await fs.cp(ctx.core.configsDir, ctx.client.buildDir, { recursive: true });
+}
+async function createComponentDir(dir) {
+    await fs.mkdir(dir);
+}
+
+const STYLE_IMPORTS_TOKEN = "{{STYLES_IMPORT}}";
+const RENDER_IMPORT_TOKEN = "{{RENDER_IMPORT}}";
+// const NODE_LOGGER = stencilNodeApi.createNodeLogger({ process: process });
+// const NODE_SYS = stencilNodeApi.createNodeSys({
+//   process: process,
+//   // @ts-ignore
+//   logger: NODE_LOGGER,
+// });
+var generate = async (ctx, pluginName) => {
+    await injectCSS(ctx, pluginName);
+    await injectBundleRender(ctx, pluginName);
+    await runStencil(ctx);
+};
+async function injectCSS(ctx, pluginName) {
+    const CUSTOMER_BUILD = path.resolve(ctx.client.buildDir, ctx[pluginName].outputOptions.buildName);
+    const allFiles = await fs.readdir(CUSTOMER_BUILD);
+    const cssFilesImportsStr = allFiles
+        .filter((fileName) => fileName.endsWith(".css"))
+        .map((fileName) => `@import '../${ctx[pluginName].outputOptions.buildName}/${fileName}';`)
+        .join("\n");
+    const content = await fs.readFile(path.resolve(ctx.core.templatesDir, "style.css.template"), "utf8");
+    await fs.writeFile(path.resolve(ctx.client.componentDir, "style.css"), content.replace(STYLE_IMPORTS_TOKEN, cssFilesImportsStr));
+}
+async function injectBundleRender(ctx, pluginName) {
+    const importStr = `import render from '../${ctx[pluginName].outputOptions.buildName}/${ctx[pluginName].outputOptions.fileName}';`;
+    const content = await fs.readFile(path.resolve(ctx.core.templatesDir, "component.tsx.template"), "utf8");
+    await fs.writeFile(path.resolve(ctx.client.componentDir, "component.tsx"), content.replace(RENDER_IMPORT_TOKEN, importStr));
+}
+async function runStencil(ctx) {
+    process.chdir(ctx.client.buildDir);
+    const logger = createNodeLogger({ process });
+    const sys = createNodeSys({ process });
+    const validated = await loadConfig({
+        logger,
+        sys,
+        config: {
+            namespace: "embeddable-wrapper",
+            srcDir: "component",
+            outputTargets: [{
+                    type: "dist"
+                }],
+        },
+    });
+    const compiler = await createCompiler(validated.config);
+    await compiler.build();
+    await compiler.destroy();
+    // await stencil.run({
+    //   args: ["build"],
+    //   logger: NODE_LOGGER,
+    //   sys: NODE_SYS,
+    //   // @ts-ignore
+    //   checkVersion: stencilNodeApi.checkVersion,
+    // });
+}
+
+var cleanup = async (ctx) => {
+    await extractBuild(ctx);
+    await removeObsoleteDir(ctx.client.buildDir);
+    await moveBuildTOBuildDir(ctx);
+};
+async function extractBuild(ctx) {
+    await fs.rename(path.resolve(ctx.client.buildDir, ctx.client.stencilBuild), ctx.client.tmpDir);
+    await fs.rename(path.resolve(ctx.client.buildDir, "embeddable-types.js"), path.join(ctx.client.tmpDir, "embeddable-types.js"));
+    await fs.rename(path.resolve(ctx.client.buildDir, "embeddable-components-meta.js"), path.join(ctx.client.tmpDir, "embeddable-components-meta.js"));
+    await fs.rename(path.resolve(ctx.client.buildDir, "embeddable-editors-meta.js"), path.join(ctx.client.tmpDir, "embeddable-editors-meta.js"));
+}
+async function removeObsoleteDir(dir) {
+    await fs.rm(dir, { recursive: true });
+}
+async function moveBuildTOBuildDir(ctx) {
+    await fs.rename(ctx.client.tmpDir, ctx.client.buildDir);
+}
+
+const EMB_YAML_FILE_REGEX$1 = /^(.*)\.emb\.ya?ml$/;
+var validate = async (ctx) => {
+    const ora = (await import('ora')).default;
+    const spinnerValidate = ora("validation...").start();
+    const filesList = await findFiles(ctx.client.srcDir, EMB_YAML_FILE_REGEX$1);
+    const componentConfigErrors = await componentConfigValidation(filesList);
+    if (componentConfigErrors.length) {
+        spinnerValidate.fail("One or more component.emb.yaml files are invalid:");
+        componentConfigErrors.forEach((errorMessage) => spinnerValidate.info(errorMessage));
+        process.exit(1);
+    }
+    spinnerValidate.succeed("validation completed");
+};
+async function componentConfigValidation(filesList) {
+    const ARRAY_ALLOWED_TYPES = ["Dimension", "Measure"];
+    const errors = [];
+    for (const [fileName, filePath] of filesList) {
+        if (!fileName.endsWith(".component"))
+            continue;
+        const fileContentRaw = await fs.readFile(filePath, "utf8");
+        const config = YAML.parse(fileContentRaw);
+        if (!("inputs" in config) || config.inputs.length === 0)
             continue;
-        unknownDimensionsOrMeasures.push(name_1);
+        config.inputs
+            .filter((inputConfig) => inputConfig === null || inputConfig === void 0 ? void 0 : inputConfig.array)
+            .forEach((inputConfig) => {
+            if (!ARRAY_ALLOWED_TYPES.includes(inputConfig === null || inputConfig === void 0 ? void 0 : inputConfig.type)) {
+                const errorMessage = `${fileName} contains invalid type value for \x1b[33m${inputConfig.name}\x1b[0m input.
+\x1b[33m${inputConfig.name}\x1b[0m is marked as \x1b[33marray\x1b[0m. Inputs marked as array support the following types: ${ARRAY_ALLOWED_TYPES.join(", ")}.
+Specified \x1b[33m${inputConfig === null || inputConfig === void 0 ? void 0 : inputConfig.type}\x1b[0m type is not supported.
+Please check the following file: \x1b[33m${filePath}\x1b[0m\n`;
+                errors.push(errorMessage);
+            }
+        });
     }
-    return unknownDimensionsOrMeasures;
+    return errors;
+}
+
+var build = async () => {
+    const config = (await import(`${process.cwd()}/embeddable.config.js`))
+        .default;
+    await validate(config);
+    await prepare(config);
+    await buildTypes(config);
+    for (const getPlugin of config.plugins) {
+        const plugin = getPlugin();
+        await plugin.validate(config);
+        await plugin.build(config);
+        await plugin.cleanup(config);
+    }
+    // NOTE: likely this will be called inside the loop above if we decide to support clients with mixed frameworks simultaneously.
+    await generate(config, "sdk-react");
+    await cleanup(config);
 };
 
-var LOAD_DATA_EVENT = "embeddable-event:load-data";
-var isLoadDataParams = function (ldp) {
-    return typeof ldp === "object" && "requestParams" in ldp && "dataLoader" in ldp;
+const oraP$1 = import('ora');
+const openP = import('open');
+const CREDENTIALS_DIR = path.resolve(os.homedir(), ".embeddable");
+const CREDENTIALS_FILE = path.resolve(CREDENTIALS_DIR, "credentials");
+const AUTH0_DOMAIN = "embeddable-dev.eu.auth0.com";
+const AUTH0_CLIENT_ID = "xOKco5ztFCpWn54bJbFkAcT8mV4LLcpG";
+var login = async () => {
+    var _a;
+    const ora = (await oraP$1).default;
+    const open = (await openP).default;
+    await resolveFiles();
+    const deviceCodePayload = {
+        client_id: AUTH0_CLIENT_ID,
+        audience: "https://api.embeddable.com/",
+    };
+    const deviceCodeResponse = await axios.post(`https://${AUTH0_DOMAIN}/oauth/device/code`, deviceCodePayload);
+    const tokenPayload = {
+        grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+        device_code: deviceCodeResponse.data["device_code"],
+        client_id: AUTH0_CLIENT_ID,
+    };
+    const authenticationSpinner = ora("waiting for code verification...").start();
+    await open(deviceCodeResponse.data["verification_uri_complete"]);
+    /**
+     * This is a recommended way to poll, since it take some time for a user to enter a `user_code` in a browser.
+     * deviceCodeResponse.data['interval'] is a recommended/calculated polling interval specified in seconds.
+     */
+    while (true) {
+        try {
+            const tokenResponse = await axios.post(`https://${AUTH0_DOMAIN}/oauth/token`, tokenPayload);
+            await fs.writeFile(CREDENTIALS_FILE, JSON.stringify(tokenResponse.data));
+            authenticationSpinner.succeed("you are successfully authenticated now!");
+            break;
+        }
+        catch (e) {
+            if (((_a = e.response.data) === null || _a === void 0 ? void 0 : _a.error) !== "authorization_pending") {
+                authenticationSpinner.fail("authentication failed. please try again.");
+                process.exit(1);
+            }
+            await sleep(deviceCodeResponse.data["interval"] * 1000);
+        }
+    }
 };
-var executeDataRequest = function (request, componentId, propertyName) {
+async function getToken() {
     var _a;
-    if (!request.from)
-        return "No dataset selected";
-    var dimensions = normalizeEntities(request.dimensions, { mapFn: getName });
-    var measures = normalizeEntities(request.measures, { mapFn: getName });
-    var timeDimensions = normalizeEntities(request.timeDimensions, {
-        // @ts-expect-error
-        filterFn: getName,
+    try {
+        const rawCredentials = await fs.readFile(CREDENTIALS_FILE, "utf-8");
+        const credentials = JSON.parse(rawCredentials.toString());
+        return (_a = credentials === null || credentials === void 0 ? void 0 : credentials.access_token) !== null && _a !== void 0 ? _a : "";
+    }
+    catch (_e) {
+        return "";
+    }
+}
+function sleep(ms) {
+    return new Promise((res) => setTimeout(res, ms));
+}
+async function resolveFiles() {
+    try {
+        await fs.access(CREDENTIALS_DIR);
+    }
+    catch (_e) {
+        await fs.mkdir(CREDENTIALS_DIR);
+    }
+    try {
+        await fs.access(CREDENTIALS_FILE);
+    }
+    catch (e) {
+        await fs.writeFile(CREDENTIALS_FILE, "");
+    }
+}
+
+var createContext = (coreRoot, clientRoot) => ({
+    core: {
+        rootDir: coreRoot,
+        templatesDir: path.resolve(coreRoot, "templates"),
+        configsDir: path.resolve(coreRoot, "configs"),
+    },
+    client: {
+        rootDir: clientRoot,
+        buildDir: path.resolve(clientRoot, ".embeddable-build"),
+        srcDir: path.resolve(clientRoot, "src"),
+        tmpDir: path.resolve(clientRoot, ".embeddable-tmp"),
+        componentDir: path.resolve(clientRoot, ".embeddable-build", "component"),
+        stencilBuild: path.resolve(clientRoot, ".embeddable-build", "dist", "embeddable-wrapper"),
+        archiveFile: path.resolve(clientRoot, "embeddable-build.zip"),
+    },
+    outputOptions: {
+        typesEntryPointFilename: "embeddable-types-entry-point.js",
+    },
+});
+
+const oraP = import('ora');
+const inquirerSelect = import('@inquirer/select');
+const EMB_YAML_FILE_REGEX = /^(.*)\.emb\.ya?ml$/;
+let ora;
+var push = async () => {
+    ora = (await oraP).default;
+    const ctx = createContext(path.resolve(__dirname, ".."), process.cwd());
+    const token = await verify(ctx);
+    const { workspaceId, name: workspaceName } = await selectWorkspace(token);
+    const spinnerArchive = ora("archivation...").start();
+    const filesList = await findFiles(ctx.client.srcDir, EMB_YAML_FILE_REGEX);
+    await archive(ctx, filesList);
+    spinnerArchive.succeed("archivation competed");
+    const spinnerPushing = ora("publishing...").start();
+    await sendBuild(ctx, { workspaceId, token });
+    spinnerPushing.succeed(`published to ${workspaceName}`);
+};
+async function selectWorkspace(token) {
+    const workspaceSpinner = ora({
+        text: "Fetching workspaces...",
+        color: "green",
+        discardStdin: false,
+    }).start();
+    const availableWorkspaces = await getWorkspaces(token);
+    let selectedWorkspace;
+    if (availableWorkspaces.length === 0) {
+        workspaceSpinner.fail("No workspaces found");
+        process.exit(1);
+    }
+    workspaceSpinner.info(`Found ${availableWorkspaces.length} workspace(s)`);
+    if (availableWorkspaces.length === 1) {
+        selectedWorkspace = availableWorkspaces[0];
+    }
+    else {
+        const select = (await inquirerSelect).default;
+        selectedWorkspace = await select({
+            message: "Select workspace to push changes",
+            choices: availableWorkspaces.map((workspace) => ({
+                name: `${workspace.name} (${workspace.workspaceId})`,
+                value: workspace,
+            })),
+        });
+    }
+    workspaceSpinner.succeed(`Workspace: ${selectedWorkspace.name} (${selectedWorkspace.workspaceId})`);
+    return selectedWorkspace;
+}
+async function verify(ctx) {
+    try {
+        await fs.access(ctx.client.buildDir);
+    }
+    catch (_e) {
+        console.error("No embeddable build was produced.");
+        process.exit(1);
+    }
+    // TODO: initiate login if no/invalid token.
+    const token = await getToken();
+    if (!token) {
+        console.error("Expired token. Please login again.");
+        process.exit(1);
+    }
+    return token;
+}
+async function archive(ctx, yamlFiles) {
+    const output = fsSync.createWriteStream(ctx.client.archiveFile);
+    const _archiver = archiver.create("zip", {
+        zlib: { level: 9 },
     });
-    var dimensionsOrMeasuresDefined = dimensions || measures || timeDimensions;
-    if (!dimensionsOrMeasuresDefined)
-        return "At least a dimension or a measure should be selected.";
-    var unknownDimensionsOrMeasures = validateOrderBy((_a = request.orderBy) !== null && _a !== void 0 ? _a : [], dimensions !== null && dimensions !== void 0 ? dimensions : [], measures !== null && measures !== void 0 ? measures : []);
-    if (unknownDimensionsOrMeasures.length) {
-        return "Cannot order by ".concat(unknownDimensionsOrMeasures.join(", "), " as no such ").concat(unknownDimensionsOrMeasures.length === 1 ? "property" : "properties", " has been loaded.");
-    }
-    var query = {
-        datasetId: request.from.datasetId,
-        embeddableId: request.from.embeddableId,
-        dimensions: dimensions,
-        measures: measures,
-        timeDimensions: timeDimensions,
-        offset: request.offset,
-        limit: request.limit,
-    };
-    window.dispatchEvent(new CustomEvent(LOAD_DATA_EVENT, {
-        bubbles: false,
-        detail: {
-            query: query,
-            componentId: componentId,
-            propertyName: propertyName,
+    _archiver.pipe(output);
+    _archiver.directory(ctx.client.buildDir, false);
+    for (const fileData of yamlFiles) {
+        _archiver.file(fileData[1], { name: `${fileData[0]}.emb.yaml` });
+    }
+    await _archiver.finalize();
+    return new Promise((resolve, _reject) => {
+        output.on("close", resolve);
+    });
+}
+async function sendBuild(ctx, { workspaceId, token }) {
+    const { FormData } = await import('formdata-node');
+    const { fileFromPath } = await Promise.resolve().then(function () { return fileFromPath$1; });
+    const file = await fileFromPath(ctx.client.archiveFile, "embeddable-build.zip");
+    const form = new FormData();
+    form.set("file", file, "embeddable-build.zip");
+    await axios.post(`https://api.embeddable.com/sdk/upload-files?workspaceId=${workspaceId}`, form, {
+        headers: {
+            "Content-Type": "multipart/form-data",
+            Authorization: `Bearer ${token}`,
         },
-    }));
-};
-var loadData = function (requestParams) { return ({
-    requestParams: requestParams,
-    dataLoader: executeDataRequest,
-}); };
-
-var getOperationObject = function (operation, value) { return ({
-    operation: operation,
-    value: value,
-    __embeddableVariableMeta: true,
-}); };
-var Value = {
-    noFilter: function () { return getOperationObject("NO_FILTER"); },
-    of: function (value) { return getOperationObject("VALUE", value); },
-};
-
-var UPDATE_VALUE_EVENT = "embeddable:value:changed";
-var setValue = function (value, componentId, eventName) {
-    var event = new CustomEvent(UPDATE_VALUE_EVENT, {
-        bubbles: false,
-        detail: {
-            componentId: componentId,
-            value: value,
-            eventName: eventName,
+        maxContentLength: Infinity,
+        maxBodyLength: Infinity,
+    });
+    await fs.rm(ctx.client.archiveFile);
+}
+async function getWorkspaces(token) {
+    try {
+        return axios
+            .get("https://api.embeddable.com/workspace", {
+            headers: {
+                Authorization: `Bearer ${token}`,
+            },
+        })
+            .then((res) => res.data);
+    }
+    catch (e) {
+        console.error(e);
+        return [];
+    }
+}
+
+var defineConfig = ({ plugins }) => {
+    const coreRoot = path.resolve(__dirname, "..");
+    const clientRoot = process.cwd();
+    return {
+        core: {
+            rootDir: coreRoot,
+            templatesDir: path.resolve(coreRoot, "templates"),
+            configsDir: path.resolve(coreRoot, "configs"),
+        },
+        client: {
+            rootDir: clientRoot,
+            buildDir: path.resolve(clientRoot, ".embeddable-build"),
+            srcDir: path.resolve(clientRoot, "src"),
+            tmpDir: path.resolve(clientRoot, ".embeddable-tmp"),
+            componentDir: path.resolve(clientRoot, ".embeddable-build", "component"),
+            stencilBuild: path.resolve(clientRoot, ".embeddable-build", "dist", "embeddable-wrapper"),
+            archiveFile: path.resolve(clientRoot, "embeddable-build.zip"),
+        },
+        outputOptions: {
+            typesEntryPointFilename: "embeddable-types-entry-point.js",
         },
+        plugins,
+    };
+};
+
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+
+// src/isObject.ts
+var isObject = (value) => typeof value === "object" && value != null && !Array.isArray(value);
+
+// src/isFunction.ts
+var isFunction = (value) => typeof value === "function";
+
+// src/isAsyncIterable.ts
+var isAsyncIterable = (value) => isObject(value) && isFunction(value[Symbol.asyncIterator]);
+
+// src/blobHelpers.ts
+var MAX_CHUNK_SIZE = 65536;
+async function* clonePart(value) {
+  if (value.byteLength <= MAX_CHUNK_SIZE) {
+    yield value;
+    return;
+  }
+  let offset = 0;
+  while (offset < value.byteLength) {
+    const size = Math.min(value.byteLength - offset, MAX_CHUNK_SIZE);
+    const buffer = value.buffer.slice(offset, offset + size);
+    offset += buffer.byteLength;
+    yield new Uint8Array(buffer);
+  }
+}
+async function* readStream(readable) {
+  const reader = readable.getReader();
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) {
+      break;
+    }
+    yield value;
+  }
+}
+async function* chunkStream(stream) {
+  for await (const value of stream) {
+    yield* clonePart(value);
+  }
+}
+var getStreamIterator = (source) => {
+  if (isAsyncIterable(source)) {
+    return chunkStream(source);
+  }
+  if (isFunction(source.getReader)) {
+    return chunkStream(readStream(source));
+  }
+  throw new TypeError(
+    "Unsupported data source: Expected either ReadableStream or async iterable."
+  );
+};
+async function* consumeNodeBlob(blob) {
+  let position = 0;
+  while (position !== blob.size) {
+    const chunk = blob.slice(
+      position,
+      Math.min(blob.size, position + MAX_CHUNK_SIZE)
+    );
+    const buffer = await chunk.arrayBuffer();
+    position += buffer.byteLength;
+    yield new Uint8Array(buffer);
+  }
+}
+async function* consumeBlobParts(parts, clone = false) {
+  for (const part of parts) {
+    if (ArrayBuffer.isView(part)) {
+      if (clone) {
+        yield* clonePart(part);
+      } else {
+        yield part;
+      }
+    } else if (isFunction(part.stream)) {
+      yield* getStreamIterator(part.stream());
+    } else {
+      yield* consumeNodeBlob(part);
+    }
+  }
+}
+function* sliceBlob(blobParts, blobSize, start = 0, end) {
+  end ??= blobSize;
+  let relativeStart = start < 0 ? Math.max(blobSize + start, 0) : Math.min(start, blobSize);
+  let relativeEnd = end < 0 ? Math.max(blobSize + end, 0) : Math.min(end, blobSize);
+  const span = Math.max(relativeEnd - relativeStart, 0);
+  let added = 0;
+  for (const part of blobParts) {
+    if (added >= span) {
+      break;
+    }
+    const partSize = ArrayBuffer.isView(part) ? part.byteLength : part.size;
+    if (relativeStart && partSize <= relativeStart) {
+      relativeStart -= partSize;
+      relativeEnd -= partSize;
+    } else {
+      let chunk;
+      if (ArrayBuffer.isView(part)) {
+        chunk = part.subarray(relativeStart, Math.min(partSize, relativeEnd));
+        added += chunk.byteLength;
+      } else {
+        chunk = part.slice(relativeStart, Math.min(partSize, relativeEnd));
+        added += chunk.size;
+      }
+      relativeEnd -= partSize;
+      relativeStart = 0;
+      yield chunk;
+    }
+  }
+}
+
+// src/Blob.ts
+var _parts, _type, _size;
+var _Blob = class _Blob {
+  /**
+   * Returns a new [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob) object.
+   * The content of the blob consists of the concatenation of the values given in the parameter array.
+   *
+   * @param blobParts An `Array` strings, or [`ArrayBuffer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer), [`ArrayBufferView`](https://developer.mozilla.org/en-US/docs/Web/API/ArrayBufferView), [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob) objects, or a mix of any of such objects, that will be put inside the [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob).
+   * @param options An optional object of type `BlobPropertyBag`.
+   */
+  constructor(blobParts = [], options = {}) {
+    /**
+     * An `Array` of [`ArrayBufferView`](https://developer.mozilla.org/en-US/docs/Web/API/ArrayBufferView) or [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob) objects, or a mix of any of such objects, that will be put inside the [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob).
+     */
+    __privateAdd(this, _parts, []);
+    /**
+     * Returns the [`MIME type`](https://developer.mozilla.org/en-US/docs/Glossary/MIME_type) of the [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob) or [`File`](https://developer.mozilla.org/en-US/docs/Web/API/File).
+     */
+    __privateAdd(this, _type, "");
+    /**
+     * Returns the size of the [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob) or [`File`](https://developer.mozilla.org/en-US/docs/Web/API/File) in bytes.
+     */
+    __privateAdd(this, _size, 0);
+    options ??= {};
+    if (typeof blobParts !== "object" || blobParts === null) {
+      throw new TypeError(
+        "Failed to construct 'Blob': The provided value cannot be converted to a sequence."
+      );
+    }
+    if (!isFunction(blobParts[Symbol.iterator])) {
+      throw new TypeError(
+        "Failed to construct 'Blob': The object must have a callable @@iterator property."
+      );
+    }
+    if (typeof options !== "object" && !isFunction(options)) {
+      throw new TypeError(
+        "Failed to construct 'Blob': parameter 2 cannot convert to dictionary."
+      );
+    }
+    const encoder = new TextEncoder();
+    for (const raw of blobParts) {
+      let part;
+      if (ArrayBuffer.isView(raw)) {
+        part = new Uint8Array(raw.buffer.slice(
+          raw.byteOffset,
+          raw.byteOffset + raw.byteLength
+        ));
+      } else if (raw instanceof ArrayBuffer) {
+        part = new Uint8Array(raw.slice(0));
+      } else if (raw instanceof _Blob) {
+        part = raw;
+      } else {
+        part = encoder.encode(String(raw));
+      }
+      __privateSet(this, _size, __privateGet(this, _size) + (ArrayBuffer.isView(part) ? part.byteLength : part.size));
+      __privateGet(this, _parts).push(part);
+    }
+    const type = options.type === void 0 ? "" : String(options.type);
+    __privateSet(this, _type, /^[\x20-\x7E]*$/.test(type) ? type : "");
+  }
+  static [Symbol.hasInstance](value) {
+    return Boolean(
+      value && typeof value === "object" && isFunction(value.constructor) && (isFunction(value.stream) || isFunction(value.arrayBuffer)) && /^(Blob|File)$/.test(value[Symbol.toStringTag])
+    );
+  }
+  /**
+   * Returns the [`MIME type`](https://developer.mozilla.org/en-US/docs/Glossary/MIME_type) of the [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob) or [`File`](https://developer.mozilla.org/en-US/docs/Web/API/File).
+   */
+  get type() {
+    return __privateGet(this, _type);
+  }
+  /**
+   * Returns the size of the [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob) or [`File`](https://developer.mozilla.org/en-US/docs/Web/API/File) in bytes.
+   */
+  get size() {
+    return __privateGet(this, _size);
+  }
+  /**
+   * Creates and returns a new [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob) object which contains data from a subset of the blob on which it's called.
+   *
+   * @param start An index into the Blob indicating the first byte to include in the new Blob. If you specify a negative value, it's treated as an offset from the end of the Blob toward the beginning. For example, -10 would be the 10th from last byte in the Blob. The default value is 0. If you specify a value for start that is larger than the size of the source Blob, the returned Blob has size 0 and contains no data.
+   * @param end An index into the Blob indicating the first byte that will *not* be included in the new Blob (i.e. the byte exactly at this index is not included). If you specify a negative value, it's treated as an offset from the end of the Blob toward the beginning. For example, -10 would be the 10th from last byte in the Blob. The default value is size.
+   * @param contentType The content type to assign to the new Blob; this will be the value of its type property. The default value is an empty string.
+   */
+  slice(start, end, contentType) {
+    return new _Blob(sliceBlob(__privateGet(this, _parts), this.size, start, end), {
+      type: contentType
     });
-    window.dispatchEvent(event);
-};
-
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol */
-
-
-var __assign = function() {
-    __assign = Object.assign || function __assign(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
-var embedType = function (typeName, typeConfig) {
-    // @ts-ignore
-    window.__EMBEDDABLE__ = window.__EMBEDDABLE__ || {};
-    // @ts-ignore
-    window.__EMBEDDABLE__.types = window.__EMBEDDABLE__.types || {};
-    // @ts-ignore
-    window.__EMBEDDABLE__.types[typeName] = __assign({ name: typeName }, typeConfig);
-};
-
-var embedOption = function (typeName, option) {
-    // @ts-ignore
-    window.__EMBEDDABLE__ = window.__EMBEDDABLE__ || {};
-    // @ts-ignore
-    if (!window.__EMBEDDABLE__.types[typeName])
-        return;
-    // @ts-ignore
-    window.__EMBEDDABLE__.types[typeName].options =
-        window.__EMBEDDABLE__.types[typeName].options || [];
-    // @ts-ignore
-    window.__EMBEDDABLE__.types[typeName].options.push(option);
-};
-
-export { Value, embedOption, embedType, isLoadDataParams, loadData, setValue };
+  }
+  /**
+   * Returns a [`Promise`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise) that resolves with a string containing the contents of the blob, interpreted as UTF-8.
+   */
+  async text() {
+    const decoder = new TextDecoder();
+    let result = "";
+    for await (const chunk of consumeBlobParts(__privateGet(this, _parts))) {
+      result += decoder.decode(chunk, { stream: true });
+    }
+    result += decoder.decode();
+    return result;
+  }
+  /**
+   * Returns a [`Promise`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise) that resolves with the contents of the blob as binary data contained in an [`ArrayBuffer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer).
+   */
+  async arrayBuffer() {
+    const view = new Uint8Array(this.size);
+    let offset = 0;
+    for await (const chunk of consumeBlobParts(__privateGet(this, _parts))) {
+      view.set(chunk, offset);
+      offset += chunk.length;
+    }
+    return view.buffer;
+  }
+  /**
+   * Returns a [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream) which upon reading returns the data contained within the [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob).
+   */
+  stream() {
+    const iterator = consumeBlobParts(__privateGet(this, _parts), true);
+    return new ReadableStream({
+      async pull(controller) {
+        const { value, done } = await iterator.next();
+        if (done) {
+          return queueMicrotask(() => controller.close());
+        }
+        controller.enqueue(value);
+      },
+      async cancel() {
+        await iterator.return();
+      }
+    });
+  }
+  get [Symbol.toStringTag]() {
+    return "Blob";
+  }
+};
+_parts = new WeakMap();
+_type = new WeakMap();
+_size = new WeakMap();
+var Blob = _Blob;
+Object.defineProperties(Blob.prototype, {
+  type: { enumerable: true },
+  size: { enumerable: true },
+  slice: { enumerable: true },
+  stream: { enumerable: true },
+  text: { enumerable: true },
+  arrayBuffer: { enumerable: true }
+});
+
+// src/File.ts
+var _name, _lastModified;
+var File = class extends Blob {
+  /**
+   * Creates a new File instance.
+   *
+   * @param fileBits An `Array` strings, or [`ArrayBuffer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer), [`ArrayBufferView`](https://developer.mozilla.org/en-US/docs/Web/API/ArrayBufferView), [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob) objects, or a mix of any of such objects, that will be put inside the [`File`](https://developer.mozilla.org/en-US/docs/Web/API/File).
+   * @param name The name of the file.
+   * @param options An options object containing optional attributes for the file.
+   */
+  constructor(fileBits, name, options = {}) {
+    super(fileBits, options);
+    /**
+     * Returns the name of the file referenced by the File object.
+     */
+    __privateAdd(this, _name, void 0);
+    /**
+     * The last modified date of the file as the number of milliseconds since the Unix epoch (January 1, 1970 at midnight). Files without a known last modified date return the current date.
+     */
+    __privateAdd(this, _lastModified, 0);
+    if (arguments.length < 2) {
+      throw new TypeError(
+        `Failed to construct 'File': 2 arguments required, but only ${arguments.length} present.`
+      );
+    }
+    __privateSet(this, _name, String(name));
+    const lastModified = options.lastModified === void 0 ? Date.now() : Number(options.lastModified);
+    if (!Number.isNaN(lastModified)) {
+      __privateSet(this, _lastModified, lastModified);
+    }
+  }
+  static [Symbol.hasInstance](value) {
+    return value instanceof Blob && value[Symbol.toStringTag] === "File" && typeof value.name === "string";
+  }
+  /**
+   * Name of the file referenced by the File object.
+   */
+  get name() {
+    return __privateGet(this, _name);
+  }
+  /* c8 ignore next 3 */
+  get webkitRelativePath() {
+    return "";
+  }
+  /**
+   * The last modified date of the file as the number of milliseconds since the Unix epoch (January 1, 1970 at midnight). Files without a known last modified date return the current date.
+   */
+  get lastModified() {
+    return __privateGet(this, _lastModified);
+  }
+  get [Symbol.toStringTag]() {
+    return "File";
+  }
+};
+_name = new WeakMap();
+_lastModified = new WeakMap();
+
+// src/fileFromPath.ts
+var _path, _start;
+var _FileFromPath = class _FileFromPath {
+  constructor(input) {
+    __privateAdd(this, _path, void 0);
+    __privateAdd(this, _start, void 0);
+    __privateSet(this, _path, input.path);
+    __privateSet(this, _start, input.start || 0);
+    this.name = basename(__privateGet(this, _path));
+    this.size = input.size;
+    this.lastModified = input.lastModified;
+  }
+  slice(start, end) {
+    return new _FileFromPath({
+      path: __privateGet(this, _path),
+      lastModified: this.lastModified,
+      start: __privateGet(this, _start) + start,
+      size: end - start
+    });
+  }
+  async *stream() {
+    const { mtimeMs } = await stat(__privateGet(this, _path));
+    if (mtimeMs > this.lastModified) {
+      throw new DOMException(
+        "The requested file could not be read, typically due to permission problems that have occurred after a reference to a file was acquired.",
+        "NotReadableError"
+      );
+    }
+    if (this.size) {
+      yield* createReadStream(__privateGet(this, _path), {
+        start: __privateGet(this, _start),
+        end: __privateGet(this, _start) + this.size - 1
+      });
+    }
+  }
+  get [Symbol.toStringTag]() {
+    return "File";
+  }
+};
+_path = new WeakMap();
+_start = new WeakMap();
+var FileFromPath = _FileFromPath;
+function createFileFromPath(path, { mtimeMs, size }, filenameOrOptions, options = {}) {
+  let filename;
+  if (isObject(filenameOrOptions)) {
+    [options, filename] = [filenameOrOptions, void 0];
+  } else {
+    filename = filenameOrOptions;
+  }
+  const file = new FileFromPath({ path, size, lastModified: mtimeMs });
+  if (!filename) {
+    filename = file.name;
+  }
+  return new File([file], filename, {
+    ...options,
+    lastModified: file.lastModified
+  });
+}
+async function fileFromPath(path, filenameOrOptions, options) {
+  const stats = await stat(path);
+  return createFileFromPath(path, stats, filenameOrOptions, options);
+}
+/*! Based on fetch-blob. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> & David Frank */
+
+var fileFromPath$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    fileFromPath: fileFromPath
+});
+
+export { build, defineConfig, login, push };
+//# sourceMappingURL=index.esm.js.map