@embeddable.com/sdk-core 2.4.14 → 2.4.16

package/configs/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "embeddable-wrapper",
+  "version": "0.0.1",
+  "main": "dist/index.cjs.js",
+  "module": "dist/index.js",
+  "es2015": "dist/esm/index.mjs",
+  "es2017": "dist/esm/index.mjs",
+  "types": "dist/types/index.d.ts",
+  "collection": "dist/collection/collection-manifest.json",
+  "collection:main": "dist/collection/index.js",
+  "unpkg": "dist/embeddable/embeddable.esm.js",
+  "license": "MIT"
+}

package/lib/buildTypes.d.ts

@@ -1,2 +1,4 @@
+export declare const EMB_TYPE_FILE_REGEX: RegExp;
+export declare const EMB_OPTIONS_FILE_REGEX: RegExp;
 declare const _default: (ctx: any) => Promise<void>;
 export default _default;

package/lib/defineConfig.d.ts

@@ -12,8 +12,9 @@ export type EmbeddableConfig = {
     errorFallbackComponent?: string;
     applicationEnvironment?: string;
     rollbarAccessToken?: string;
+    previewBaseUrl?: string;
 };
-declare const _default: ({ plugins, pushBaseUrl, audienceUrl, authDomain, authClientId, errorFallbackComponent, applicationEnvironment, rollbarAccessToken, }: EmbeddableConfig) => {
+declare const _default: ({ plugins, pushBaseUrl, audienceUrl, authDomain, authClientId, errorFallbackComponent, applicationEnvironment, rollbarAccessToken, previewBaseUrl, }: EmbeddableConfig) => {
     core: {
         rootDir: string;
         templatesDir: string;
@@ -34,6 +35,7 @@ declare const _default: ({ plugins, pushBaseUrl, audienceUrl, authDomain, authCl
     };
     pushBaseUrl: string;
     audienceUrl: string;
+    previewBaseUrl: string;
     authDomain: string;
     authClientId: string;
     applicationEnvironment: string;

package/lib/dev.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/index.d.ts

@@ -1,4 +1,5 @@
 export { default as build } from "./build";
 export { default as login } from "./login";
 export { default as push } from "./push";
+export { default as dev } from "./dev";
 export { default as defineConfig } from "./defineConfig";

package/lib/index.esm.js

@@ -8,10 +8,10 @@ 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 require$$1 from 'path';
-import require$$1__default, { basename } from 'path';
+import * as path$2 from 'path';
+import path__default, { basename } from 'path';
 import require$$4$1 from 'util';
-import require$$1$1 from 'os';
+import require$$1 from 'os';
 import require$$3 from 'http';
 import require$$4 from 'https';
 import require$$0$1 from 'url';
@@ -19,6 +19,8 @@ import require$$2$1, { createReadStream } from 'fs';
 import * as os$1 from 'node:os';
 import axios from 'axios';
 import * as archiver from 'archiver';
+import { WebSocketServer } from 'ws';
+import * as chokidar from 'chokidar';
 import { stat } from 'fs/promises';
 
 var findFiles = async (initialSrcDir, regex) => {
@@ -333,11 +335,11 @@ const formatErrorPath = (path) => {
     return formatted;
 };
 
-const oraP$3 = import('ora');
+const oraP$4 = 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$3).default;
+    const ora = (await oraP$4).default;
     const progress = ora("building types...").start();
     await generate$1(ctx);
     await build$1(ctx);
@@ -354,17 +356,16 @@ async function generate$1(ctx) {
     await fs$1.writeFile(path$1.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}`,
+                entry: path$1.resolve(ctx.client.rootDir, ctx.outputOptions.typesEntryPointFilename),
                 formats: ["es"],
                 fileName: "embeddable-types",
             },
-            outDir: ".embeddable-build/",
+            outDir: ctx.client.buildDir,
         },
     });
 }
@@ -413,15 +414,21 @@ async function injectBundleRender(ctx, pluginName) {
     await fs$1.writeFile(path$1.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 });
+    var _a, _b;
+    const logger = ((_a = ctx.dev) === null || _a === void 0 ? void 0 : _a.logger) || createNodeLogger({ process });
+    const sys = ((_b = ctx.dev) === null || _b === void 0 ? void 0 : _b.sys) || createNodeSys({ process });
+    const devMode = !!ctx.dev;
     const validated = await loadConfig({
+        initTsConfig: true,
         logger,
         sys,
         config: {
+            devMode,
+            rootDir: ctx.client.buildDir,
+            configPath: path$1.resolve(ctx.client.buildDir, "stencil.config.ts"),
+            tsconfig: path$1.resolve(ctx.client.buildDir, "tsconfig.json"),
             namespace: "embeddable-wrapper",
-            srcDir: "component",
+            srcDir: path$1.resolve(ctx.client.buildDir, "component"),
             outputTargets: [
                 {
                     type: "dist",
@@ -432,6 +439,7 @@ async function runStencil(ctx) {
     const compiler = await createCompiler(validated.config);
     await compiler.build();
     await compiler.destroy();
+    process.chdir(ctx.client.rootDir);
 }
 async function generateSourceMap(ctx, pluginName) {
     const componentBuildDir = path$1.resolve(ctx.client.buildDir, ctx[pluginName].outputOptions.buildName);
@@ -4496,7 +4504,7 @@ const checkNodeVersion$1 = () => {
         throw new Error(`Node version ${minMajor}.${minMinor} or higher is required. You are running ${major}.${minor}.`);
     }
 };
-var validate = async (ctx) => {
+var validate = async (ctx, exitIfInvalid = true) => {
     checkNodeVersion$1();
     const ora = (await import('ora')).default;
     const spinnerValidate = ora("data model validation...").start();
@@ -4505,9 +4513,12 @@ var validate = async (ctx) => {
     if (dataModelErrors.length) {
         spinnerValidate.fail("One or more cube.yaml files are invalid:");
         dataModelErrors.forEach((errorMessage) => spinnerValidate.info(errorMessage));
-        process.exit(1);
+        if (exitIfInvalid) {
+            process.exit(1);
+        }
     }
     spinnerValidate.succeed("data model validation completed");
+    return dataModelErrors.length === 0;
 };
 async function dataModelsValidation(filesList) {
     const errors = [];
@@ -16790,7 +16801,7 @@ sourceMap.SourceMapConsumer = sourceMapConsumer.SourceMapConsumer;
 sourceMap.SourceNode = sourceNode.SourceNode;
 
 var SourceMapConsumer = sourceMap.SourceMapConsumer;
-var path = require$$1__default;
+var path = path__default;
 var fs = require$$2$1;
 
 /**
@@ -19057,7 +19068,7 @@ var setupCustomJSON = function(JSON) {
 var json3 = setupCustomJSON;
 
 var util = require$$4$1;
-var os = require$$1$1;
+var os = require$$1;
 
 var packageJson = require$$2;
 var Client = rollbar$1;
@@ -19833,7 +19844,7 @@ const reportErrorToRollbar = async (error) => {
 
 const getSdkPackageVersionInfo = (config) => {
   try {
-    const packageJsonFilePath = require$$1.resolve(
+    const packageJsonFilePath = path$2.resolve(
       config.client.rootDir,
       "package.json",
     );
@@ -19877,11 +19888,11 @@ async function getUserData() {
   }
 }
 
-const oraP$2 = import('ora');
-let ora$1;
+const oraP$3 = import('ora');
+let ora$2;
 const checkNodeVersion = async () => {
-    ora$1 = (await oraP$2).default;
-    ora$1("checking node version...");
+    ora$2 = (await oraP$3).default;
+    ora$2("checking node version...");
     const [major, minor] = process.versions.node.split(".").map(Number);
     const engines = require("../package.json").engines.node;
     const [minMajor, minMinor] = engines
@@ -19889,7 +19900,7 @@ const checkNodeVersion = async () => {
         .map((v) => v.replace(/[^\d]/g, ""))
         .map(Number);
     if (major < minMajor || (major === minMajor && minor < minMinor)) {
-        ora$1({
+        ora$2({
             text: `Node version ${minMajor}.${minMinor} or higher is required. You are running ${major}.${minor}.`,
             color: "red",
         }).fail();
@@ -19917,16 +19928,17 @@ var build = async () => {
     catch (error) {
         await reportErrorToRollbar(error);
         console.log(error);
-        throw error;
+        process.exit(1);
     }
 };
 
-const oraP$1 = import('ora');
+const oraP$2 = import('ora');
 const openP = import('open');
 var login = async () => {
     var _a;
+    const ora = (await oraP$2).default;
+    const authenticationSpinner = ora("waiting for code verification...").start();
     try {
-        const ora = (await oraP$1).default;
         const open = (await openP).default;
         const config = await provideConfig();
         await resolveFiles();
@@ -19940,7 +19952,6 @@ var login = async () => {
             device_code: deviceCodeResponse.data["device_code"],
             client_id: config.authClientId,
         };
-        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.
@@ -19963,9 +19974,10 @@ var login = async () => {
         }
     }
     catch (error) {
+        authenticationSpinner.fail("authentication failed. please try again.");
         await reportErrorToRollbar(error);
         console.log(error);
-        throw error;
+        process.exit(1);
     }
 };
 async function getToken() {
@@ -19997,22 +20009,22 @@ async function resolveFiles() {
     }
 }
 
-const oraP = import('ora');
+const oraP$1 = import('ora');
 const inquirerSelect = import('@inquirer/select');
 const CUBE_YAML_FILE_REGEX = /^(.*)\.cube\.ya?ml$/;
-let ora;
+let ora$1;
 var push = async () => {
     try {
         checkNodeVersion();
-        ora = (await oraP).default;
+        ora$1 = (await oraP$1).default;
         const config = await provideConfig();
         const token = await verify(config);
         const { workspaceId, name: workspaceName } = await selectWorkspace(config, token);
-        const spinnerArchive = ora("archivation...").start();
+        const spinnerArchive = ora$1("archivation...").start();
         const filesList = await findFiles(config.client.srcDir, CUBE_YAML_FILE_REGEX);
         await archive(config, filesList);
         spinnerArchive.succeed("archivation competed");
-        const spinnerPushing = ora(`publishing to ${workspaceName} using ${config.pushBaseUrl}...`).start();
+        const spinnerPushing = ora$1(`publishing to ${workspaceName} using ${config.pushBaseUrl}...`).start();
         await sendBuild(config, { workspaceId, token });
         spinnerPushing.succeed(`published to ${workspaceName} using ${config.pushBaseUrl}`);
     }
@@ -20023,7 +20035,7 @@ var push = async () => {
     }
 };
 async function selectWorkspace(ctx, token) {
-    const workspaceSpinner = ora({
+    const workspaceSpinner = ora$1({
         text: `Fetching workspaces using ${ctx.pushBaseUrl}...`,
         color: "green",
         discardStdin: false,
@@ -20067,13 +20079,15 @@ async function verify(ctx) {
     }
     return token;
 }
-async function archive(ctx, yamlFiles) {
+async function archive(ctx, yamlFiles, includeBuild = true) {
     const output = fsSync.createWriteStream(ctx.client.archiveFile);
     const _archiver = archiver.create("zip", {
         zlib: { level: 9 },
     });
     _archiver.pipe(output);
-    _archiver.directory(ctx.client.buildDir, false);
+    if (includeBuild) {
+        _archiver.directory(ctx.client.buildDir, false);
+    }
     for (const fileData of yamlFiles) {
         _archiver.file(fileData[1], { name: `${fileData[0]}.cube.yaml` });
     }
@@ -20099,13 +20113,14 @@ async function sendBuild(ctx, { workspaceId, token }) {
     await fs$1.rm(ctx.client.archiveFile);
 }
 async function getWorkspaces(ctx, token, workspaceSpinner) {
+    var _a;
     try {
         const response = await axios.get(`${ctx.pushBaseUrl}/workspace`, {
             headers: {
                 Authorization: `Bearer ${token}`,
             },
         });
-        return response.data;
+        return (_a = response.data) === null || _a === void 0 ? void 0 : _a.filter((w) => !w.devWorkspace);
     }
     catch (e) {
         if (e.response.status === 401) {
@@ -20118,7 +20133,171 @@ async function getWorkspaces(ctx, token, workspaceSpinner) {
     }
 }
 
-var defineConfig = ({ plugins, pushBaseUrl, audienceUrl, authDomain, authClientId, errorFallbackComponent, applicationEnvironment, rollbarAccessToken, }) => {
+const oraP = import('ora');
+let wss;
+let changedFiles = [];
+let browserWindow = null;
+let ora;
+let previewWorkspace;
+const SERVER_PORT = 8926;
+const buildWebComponent = async (config) => {
+    await generate(config, "sdk-react");
+};
+var dev = async () => {
+    const http = require("http");
+    ora = (await oraP).default;
+    process.on("warning", (e) => console.warn(e.stack));
+    const logger = createNodeLogger({ process });
+    const sys = createNodeSys({ process });
+    const config = {
+        dev: {
+            watch: true,
+            logger,
+            sys,
+        },
+        ...(await provideConfig()),
+    };
+    await prepare(config);
+    const finalhandler = require("finalhandler");
+    const serveStatic = require("serve-static");
+    const serve = serveStatic(config.client.buildDir);
+    const workspacePreparation = ora("Preparing workspace...").start();
+    previewWorkspace = await getPreviewWorkspace(config);
+    workspacePreparation.succeed("Workspace is ready");
+    const server = http.createServer((request, res) => {
+        res.setHeader("Access-Control-Allow-Origin", "*");
+        const done = finalhandler(request, res);
+        serve(request, res, done);
+    });
+    wss = new WebSocketServer({ server });
+    server.listen(SERVER_PORT, async () => {
+        const watchers = [];
+        if (sys === null || sys === void 0 ? void 0 : sys.onProcessInterrupt) {
+            sys.onProcessInterrupt(async () => await onClose(server, sys, watchers, config));
+        }
+        await sendDataModels(config);
+        for (const getPlugin of config.plugins) {
+            const plugin = getPlugin();
+            await plugin.validate(config);
+            const watcher = await plugin.build(config);
+            await configureWatcher(watcher, config);
+            watchers.push(watcher);
+        }
+        const modelWatcher = dataModelWatcher(config);
+        watchers.push(modelWatcher);
+    });
+};
+const configureWatcher = async (watcher, ctx) => {
+    watcher.on("change", (path) => {
+        changedFiles.push(path);
+    });
+    watcher.on("event", async (e) => {
+        var _a;
+        if (e.code === "BUNDLE_START") {
+            await onBuildStart(ctx);
+        }
+        if (e.code === "BUNDLE_END") {
+            await onBundleBuildEnd(ctx);
+            changedFiles = [];
+        }
+        if (e.code === "ERROR") {
+            sendMessage("componentsBuildError", { error: (_a = e.error) === null || _a === void 0 ? void 0 : _a.message });
+            changedFiles = [];
+        }
+    });
+};
+const sendMessage = (type, meta = {}) => {
+    wss.clients.forEach((ws) => {
+        ws.send(JSON.stringify({ type, ...meta }));
+    });
+};
+const typeFilesFilter = (f) => EMB_OPTIONS_FILE_REGEX.test(f) || EMB_TYPE_FILE_REGEX.test(f);
+const onlyTypesChanged = () => changedFiles.length !== 0 &&
+    changedFiles.filter(typeFilesFilter).length === changedFiles.length;
+const isTypeFileChanged = () => changedFiles.findIndex(typeFilesFilter) >= 0;
+const onBuildStart = async (ctx) => {
+    if (changedFiles.length === 0 || isTypeFileChanged()) {
+        await buildTypes(ctx);
+    }
+    sendMessage("componentsBuildStart", { changedFiles });
+};
+const onBundleBuildEnd = async (ctx) => {
+    if (!onlyTypesChanged() || changedFiles.length === 0) {
+        await buildWebComponent(ctx);
+    }
+    if (browserWindow == null) {
+        const open = (await import('open')).default;
+        browserWindow = await open(`${ctx.previewBaseUrl}/workspace/${previewWorkspace}`);
+    }
+    else {
+        sendMessage("componentsBuildSuccess");
+    }
+};
+const dataModelWatcher = (ctx) => {
+    const fsWatcher = chokidar.watch([path$2.resolve(ctx.client.srcDir, "**/*.cube.{yaml,yml}")], {
+        ignoreInitial: true,
+    });
+    fsWatcher.on("all", async () => {
+        await sendDataModels(ctx);
+    });
+    return fsWatcher;
+};
+const sendDataModels = async (ctx) => {
+    sendMessage("dataModelsUpdateStart");
+    const isValid = await validate(ctx, false);
+    if (isValid) {
+        const token = await getToken();
+        const sending = ora("synchronising data models...").start();
+        const filesList = await findFiles(ctx.client.srcDir, CUBE_YAML_FILE_REGEX);
+        await archive(ctx, filesList, false);
+        await sendBuild(ctx, { workspaceId: previewWorkspace, token });
+        sending.succeed(`data models synchronized`);
+        sendMessage("dataModelsUpdateSuccess");
+    }
+    else {
+        sendMessage("dataModelsUpdateError");
+    }
+};
+const onClose = async (server, sys, watchers, config) => {
+    server.close();
+    wss.close();
+    browserWindow === null || browserWindow === void 0 ? void 0 : browserWindow.unref();
+    for (const watcher of watchers) {
+        if (watcher.close) {
+            await watcher.close();
+        }
+    }
+    for (const getPlugin of config.plugins) {
+        const plugin = getPlugin();
+        await plugin.cleanup(config);
+    }
+    await removeIfExists(config);
+    await sys.destroy();
+    process.exit(0);
+};
+const getPreviewWorkspace = async (ctx) => {
+    const token = await getToken();
+    try {
+        const response = await axios.get(`${ctx.pushBaseUrl}/workspace/dev-workspace`, {
+            headers: {
+                Authorization: `Bearer ${token}`,
+            },
+        });
+        return response.data;
+    }
+    catch (e) {
+        if (e.response.status === 401) {
+            // login and retry
+            await login();
+            return await getPreviewWorkspace(ctx);
+        }
+        else {
+            throw e;
+        }
+    }
+};
+
+var defineConfig = ({ plugins, pushBaseUrl, audienceUrl, authDomain, authClientId, errorFallbackComponent, applicationEnvironment, rollbarAccessToken, previewBaseUrl, }) => {
     const coreRoot = path$1.resolve(__dirname, "..");
     const clientRoot = process.cwd();
     return {
@@ -20144,6 +20323,7 @@ var defineConfig = ({ plugins, pushBaseUrl, audienceUrl, authDomain, authClientI
         },
         pushBaseUrl: pushBaseUrl !== null && pushBaseUrl !== void 0 ? pushBaseUrl : "https://api.embeddable.com",
         audienceUrl: audienceUrl !== null && audienceUrl !== void 0 ? audienceUrl : "https://auth.embeddable.com",
+        previewBaseUrl: previewBaseUrl !== null && previewBaseUrl !== void 0 ? previewBaseUrl : "https://app.embeddable.com",
         authDomain: authDomain !== null && authDomain !== void 0 ? authDomain : "auth.embeddable.com",
         authClientId: authClientId !== null && authClientId !== void 0 ? authClientId : "dygrSUmI6HmgY5ymVbEAoLDEBxIOyr1V",
         applicationEnvironment: applicationEnvironment !== null && applicationEnvironment !== void 0 ? applicationEnvironment : "production",
@@ -20552,5 +20732,5 @@ var fileFromPath$1 = /*#__PURE__*/Object.freeze({
     fileFromPath: fileFromPath
 });
 
-export { build, defineConfig, login, push };
+export { build, defineConfig, dev, login, push };
 //# sourceMappingURL=index.esm.js.map