@embeddable.com/sdk-react 4.0.0 → 4.0.1-next.0

package/lib/index.js

@@ -1,1215 +0,0 @@
-'use strict';
-
-var path = require('node:path');
-var fs$2 = require('fs/promises');
-var path$1 = require('path');
-var vite = require('vite');
-var ora = require('ora');
-var viteReactPlugin = require('@vitejs/plugin-react');
-var fs = require('node:fs/promises');
-var url = require('node:url');
-var globalRegistrator = require('@happy-dom/global-registrator');
-require('node:child_process');
-var crypto = require('node:crypto');
-var zod = require('zod');
-var parser = require('@babel/parser');
-var traverse = require('@babel/traverse');
-var fs$1 = require('fs');
-
-function _interopNamespaceDefault(e) {
-    var n = Object.create(null);
-    if (e) {
-        Object.keys(e).forEach(function (k) {
-            if (k !== 'default') {
-                var d = Object.getOwnPropertyDescriptor(e, k);
-                Object.defineProperty(n, k, d.get ? d : {
-                    enumerable: true,
-                    get: function () { return e[k]; }
-                });
-            }
-        });
-    }
-    n.default = e;
-    return Object.freeze(n);
-}
-
-var path__namespace$1 = /*#__PURE__*/_interopNamespaceDefault(path);
-var fs__namespace$2 = /*#__PURE__*/_interopNamespaceDefault(fs$2);
-var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path$1);
-var vite__namespace = /*#__PURE__*/_interopNamespaceDefault(vite);
-var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
-var url__namespace = /*#__PURE__*/_interopNamespaceDefault(url);
-var crypto__namespace = /*#__PURE__*/_interopNamespaceDefault(crypto);
-var fs__namespace$1 = /*#__PURE__*/_interopNamespaceDefault(fs$1);
-
-var createContext = (pluginRoot, coreCtx) => {
-    coreCtx["sdk-react"] = {
-        rootDir: pluginRoot,
-        templatesDir: path.resolve(pluginRoot, "templates"),
-        outputOptions: {
-            fileName: "embeddable-prepared",
-            buildName: "embeddable-prepared-build",
-            componentsEntryPointFilename: "embeddable-entry-point.jsx",
-        },
-    };
-};
-
-globalRegistrator.GlobalRegistrator.register({
-    url: "http://localhost:3000",
-    width: 1920,
-    height: 1080,
-});
-const loadComponentMeta = async (moduleId) => {
-    const module = await import(url__namespace.pathToFileURL(moduleId).href);
-    return module.meta;
-};
-
-var findFiles = async (initialSrcDir, regex) => {
-    const filesList = [];
-    async function findFilesRec(srcDir) {
-        const allFiles = await fs.readdir(srcDir);
-        for (const file of allFiles) {
-            const filePath = path.join(srcDir, file);
-            const status = await fs.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;
-};
-
-var util;
-(function (util) {
-    util.assertEqual = (val) => val;
-    function assertIs(_arg) { }
-    util.assertIs = assertIs;
-    function assertNever(_x) {
-        throw new Error();
-    }
-    util.assertNever = assertNever;
-    util.arrayToEnum = (items) => {
-        const obj = {};
-        for (const item of items) {
-            obj[item] = item;
-        }
-        return obj;
-    };
-    util.getValidEnumValues = (obj) => {
-        const validKeys = util.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
-        const filtered = {};
-        for (const k of validKeys) {
-            filtered[k] = obj[k];
-        }
-        return util.objectValues(filtered);
-    };
-    util.objectValues = (obj) => {
-        return util.objectKeys(obj).map(function (e) {
-            return obj[e];
-        });
-    };
-    util.objectKeys = typeof Object.keys === "function" // eslint-disable-line ban/ban
-        ? (obj) => Object.keys(obj) // eslint-disable-line ban/ban
-        : (object) => {
-            const keys = [];
-            for (const key in object) {
-                if (Object.prototype.hasOwnProperty.call(object, key)) {
-                    keys.push(key);
-                }
-            }
-            return keys;
-        };
-    util.find = (arr, checker) => {
-        for (const item of arr) {
-            if (checker(item))
-                return item;
-        }
-        return undefined;
-    };
-    util.isInteger = typeof Number.isInteger === "function"
-        ? (val) => Number.isInteger(val) // eslint-disable-line ban/ban
-        : (val) => typeof val === "number" && isFinite(val) && Math.floor(val) === val;
-    function joinValues(array, separator = " | ") {
-        return array
-            .map((val) => (typeof val === "string" ? `'${val}'` : val))
-            .join(separator);
-    }
-    util.joinValues = joinValues;
-    util.jsonStringifyReplacer = (_, value) => {
-        if (typeof value === "bigint") {
-            return value.toString();
-        }
-        return value;
-    };
-})(util || (util = {}));
-var objectUtil;
-(function (objectUtil) {
-    objectUtil.mergeShapes = (first, second) => {
-        return {
-            ...first,
-            ...second, // second overwrites first
-        };
-    };
-})(objectUtil || (objectUtil = {}));
-util.arrayToEnum([
-    "string",
-    "nan",
-    "number",
-    "integer",
-    "float",
-    "boolean",
-    "date",
-    "bigint",
-    "symbol",
-    "function",
-    "undefined",
-    "null",
-    "array",
-    "object",
-    "unknown",
-    "promise",
-    "void",
-    "never",
-    "map",
-    "set",
-]);
-
-const ZodIssueCode = util.arrayToEnum([
-    "invalid_type",
-    "invalid_literal",
-    "custom",
-    "invalid_union",
-    "invalid_union_discriminator",
-    "invalid_enum_value",
-    "unrecognized_keys",
-    "invalid_arguments",
-    "invalid_return_type",
-    "invalid_date",
-    "invalid_string",
-    "too_small",
-    "too_big",
-    "invalid_intersection_types",
-    "not_multiple_of",
-    "not_finite",
-]);
-class ZodError extends Error {
-    constructor(issues) {
-        super();
-        this.issues = [];
-        this.addIssue = (sub) => {
-            this.issues = [...this.issues, sub];
-        };
-        this.addIssues = (subs = []) => {
-            this.issues = [...this.issues, ...subs];
-        };
-        const actualProto = new.target.prototype;
-        if (Object.setPrototypeOf) {
-            // eslint-disable-next-line ban/ban
-            Object.setPrototypeOf(this, actualProto);
-        }
-        else {
-            this.__proto__ = actualProto;
-        }
-        this.name = "ZodError";
-        this.issues = issues;
-    }
-    get errors() {
-        return this.issues;
-    }
-    format(_mapper) {
-        const mapper = _mapper ||
-            function (issue) {
-                return issue.message;
-            };
-        const fieldErrors = { _errors: [] };
-        const processError = (error) => {
-            for (const issue of error.issues) {
-                if (issue.code === "invalid_union") {
-                    issue.unionErrors.map(processError);
-                }
-                else if (issue.code === "invalid_return_type") {
-                    processError(issue.returnTypeError);
-                }
-                else if (issue.code === "invalid_arguments") {
-                    processError(issue.argumentsError);
-                }
-                else if (issue.path.length === 0) {
-                    fieldErrors._errors.push(mapper(issue));
-                }
-                else {
-                    let curr = fieldErrors;
-                    let i = 0;
-                    while (i < issue.path.length) {
-                        const el = issue.path[i];
-                        const terminal = i === issue.path.length - 1;
-                        if (!terminal) {
-                            curr[el] = curr[el] || { _errors: [] };
-                            // if (typeof el === "string") {
-                            //   curr[el] = curr[el] || { _errors: [] };
-                            // } else if (typeof el === "number") {
-                            //   const errorArray: any = [];
-                            //   errorArray._errors = [];
-                            //   curr[el] = curr[el] || errorArray;
-                            // }
-                        }
-                        else {
-                            curr[el] = curr[el] || { _errors: [] };
-                            curr[el]._errors.push(mapper(issue));
-                        }
-                        curr = curr[el];
-                        i++;
-                    }
-                }
-            }
-        };
-        processError(this);
-        return fieldErrors;
-    }
-    static assert(value) {
-        if (!(value instanceof ZodError)) {
-            throw new Error(`Not a ZodError: ${value}`);
-        }
-    }
-    toString() {
-        return this.message;
-    }
-    get message() {
-        return JSON.stringify(this.issues, util.jsonStringifyReplacer, 2);
-    }
-    get isEmpty() {
-        return this.issues.length === 0;
-    }
-    flatten(mapper = (issue) => issue.message) {
-        const fieldErrors = {};
-        const formErrors = [];
-        for (const sub of this.issues) {
-            if (sub.path.length > 0) {
-                fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
-                fieldErrors[sub.path[0]].push(mapper(sub));
-            }
-            else {
-                formErrors.push(mapper(sub));
-            }
-        }
-        return { formErrors, fieldErrors };
-    }
-    get formErrors() {
-        return this.flatten();
-    }
-}
-ZodError.create = (issues) => {
-    const error = new ZodError(issues);
-    return error;
-};
-
-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 errorUtil;
-(function (errorUtil) {
-    errorUtil.errToObj = (message) => typeof message === "string" ? { message } : message || {};
-    errorUtil.toString = (message) => typeof message === "string" ? message : message === null || message === undefined ? undefined : message.message;
-})(errorUtil || (errorUtil = {}));
-var ZodFirstPartyTypeKind;
-(function (ZodFirstPartyTypeKind) {
-    ZodFirstPartyTypeKind["ZodString"] = "ZodString";
-    ZodFirstPartyTypeKind["ZodNumber"] = "ZodNumber";
-    ZodFirstPartyTypeKind["ZodNaN"] = "ZodNaN";
-    ZodFirstPartyTypeKind["ZodBigInt"] = "ZodBigInt";
-    ZodFirstPartyTypeKind["ZodBoolean"] = "ZodBoolean";
-    ZodFirstPartyTypeKind["ZodDate"] = "ZodDate";
-    ZodFirstPartyTypeKind["ZodSymbol"] = "ZodSymbol";
-    ZodFirstPartyTypeKind["ZodUndefined"] = "ZodUndefined";
-    ZodFirstPartyTypeKind["ZodNull"] = "ZodNull";
-    ZodFirstPartyTypeKind["ZodAny"] = "ZodAny";
-    ZodFirstPartyTypeKind["ZodUnknown"] = "ZodUnknown";
-    ZodFirstPartyTypeKind["ZodNever"] = "ZodNever";
-    ZodFirstPartyTypeKind["ZodVoid"] = "ZodVoid";
-    ZodFirstPartyTypeKind["ZodArray"] = "ZodArray";
-    ZodFirstPartyTypeKind["ZodObject"] = "ZodObject";
-    ZodFirstPartyTypeKind["ZodUnion"] = "ZodUnion";
-    ZodFirstPartyTypeKind["ZodDiscriminatedUnion"] = "ZodDiscriminatedUnion";
-    ZodFirstPartyTypeKind["ZodIntersection"] = "ZodIntersection";
-    ZodFirstPartyTypeKind["ZodTuple"] = "ZodTuple";
-    ZodFirstPartyTypeKind["ZodRecord"] = "ZodRecord";
-    ZodFirstPartyTypeKind["ZodMap"] = "ZodMap";
-    ZodFirstPartyTypeKind["ZodSet"] = "ZodSet";
-    ZodFirstPartyTypeKind["ZodFunction"] = "ZodFunction";
-    ZodFirstPartyTypeKind["ZodLazy"] = "ZodLazy";
-    ZodFirstPartyTypeKind["ZodLiteral"] = "ZodLiteral";
-    ZodFirstPartyTypeKind["ZodEnum"] = "ZodEnum";
-    ZodFirstPartyTypeKind["ZodEffects"] = "ZodEffects";
-    ZodFirstPartyTypeKind["ZodNativeEnum"] = "ZodNativeEnum";
-    ZodFirstPartyTypeKind["ZodOptional"] = "ZodOptional";
-    ZodFirstPartyTypeKind["ZodNullable"] = "ZodNullable";
-    ZodFirstPartyTypeKind["ZodDefault"] = "ZodDefault";
-    ZodFirstPartyTypeKind["ZodCatch"] = "ZodCatch";
-    ZodFirstPartyTypeKind["ZodPromise"] = "ZodPromise";
-    ZodFirstPartyTypeKind["ZodBranded"] = "ZodBranded";
-    ZodFirstPartyTypeKind["ZodPipeline"] = "ZodPipeline";
-    ZodFirstPartyTypeKind["ZodReadonly"] = "ZodReadonly";
-})(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
-
-const errorFormatter = (issues) => {
-    const errors = [];
-    for (let issue of issues) {
-        if (issue.code === ZodIssueCode.invalid_union && issue.unionErrors.length) {
-            const error = issue.unionErrors[issue.unionErrors.length - 1];
-            issue = error.issues[error.issues.length - 1];
-        }
-        const path = formatErrorPath(issue.path);
-        const message = issue.message;
-        errors.push(`"${path}": ${message}`);
-    }
-    return errors;
-};
-const formatErrorPath = (path) => {
-    let formatted = "";
-    for (const pathElement of path) {
-        if (formatted.length === 0) {
-            formatted = `${pathElement}`;
-        }
-        else {
-            formatted +=
-                typeof pathElement === "number"
-                    ? `[${pathElement}]`
-                    : `.${pathElement}`;
-        }
-    }
-    return formatted;
-};
-
-/**
- *  Get the hash of the content string. It returns the first 5 characters of the hash
- *  Example: getContentHash("Hello World")
- * @param contentString  The content string to hash
- * @returns
- */
-const getContentHash = (contentString) => {
-    return crypto__namespace
-        .createHash("md5")
-        .update(contentString)
-        .digest("hex")
-        .substring(0, 5);
-};
-
-/**
- * TODO: for some reason code from @embeddable.com/extract-components-config
- * is being cached. Thus we use this code duplication in place. Please investigate and fix.
- */
-var extractComponentsConfigPlugin = ({ globalKey, outputDir, fileName, componentFileRegex, isDev = false, searchEntry = "", }) => {
-    let configs = [];
-    return {
-        name: "extract-components-config",
-        moduleParsed: async (moduleInfo) => {
-            var _a;
-            if (componentFileRegex.test(moduleInfo.id) &&
-                ((_a = moduleInfo.code) === null || _a === undefined ? undefined : _a.includes(searchEntry))) {
-                try {
-                    const meta = await loadComponentMeta(moduleInfo.id);
-                    const configJSON = JSON.stringify(meta, (_key, value) => typeof value === "object" &&
-                        value !== null &&
-                        "__embeddableType" in value
-                        ? value.toString()
-                        : value);
-                    configs.push(configJSON);
-                }
-                catch (error) {
-                    console.log("Error parsing component meta: ", moduleInfo.id);
-                    console.error(error);
-                }
-            }
-        },
-        buildEnd: async () => {
-            const template = `
-globalThis.__EMBEDDABLE__ = globalThis.__EMBEDDABLE__ || {};
-globalThis.__EMBEDDABLE__.${globalKey} = globalThis.__EMBEDDABLE__.${globalKey} || [
-  __PLACEHOLDER__
-];
-      `;
-            // sort to make sure the hash is consistent
-            configs.sort((a, b) => a.localeCompare(b));
-            const contentString = configs.filter(Boolean).join(",\n");
-            let newFileName = fileName;
-            if (!isDev) {
-                const fileHash = getContentHash(contentString);
-                const fileHashExtention = `-${fileHash}.js`;
-                newFileName = `${fileName.replace(".js", fileHashExtention)}`;
-            }
-            await fs__namespace.writeFile(`${outputDir}/${newFileName}`, template.replace("__PLACEHOLDER__", contentString));
-            configs = [];
-        },
-    };
-};
-
-/******************************************************************************
-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, Iterator */
-
-
-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 DEFAULT_LOCALE = "en-US";
-var createBuiltInType = function (name, typeConfig) {
-    if (typeConfig === undefined) { typeConfig = {}; }
-    return ({
-        __embeddableType: "built-in",
-        toString: function () { return name; },
-        typeConfig: __assign({ label: name, optionLabel: function () { return name; } }, typeConfig),
-    });
-};
-var STRING = "string";
-var NUMBER = "number";
-var BOOLEAN = "boolean";
-var TIME = "time";
-var TIME_RANGE = "timeRange";
-var GRANULARITY = "granularity";
-var DATASET = "dataset";
-var MEASURE = "measure";
-var DIMENSION = "dimension";
-var DIMENSION_OR_MEASURE = "dimensionOrMeasure";
-var ALL_NATIVE_TYPES = [
-    STRING,
-    NUMBER,
-    BOOLEAN,
-    TIME,
-    TIME_RANGE,
-    GRANULARITY,
-    DATASET,
-    MEASURE,
-    DIMENSION,
-    DIMENSION_OR_MEASURE,
-];
-
-createBuiltInType("string", {
-    transform: function (value) { return value; },
-    optionLabel: function (value) {
-        return Array.isArray(value)
-            ? "[".concat(value.map(function (v) { return "\"".concat(v, "\""); }).join(","), "]")
-            : "\"".concat(value, "\"");
-    },
-});
-createBuiltInType("number", {
-    transform: function (value) {
-        return Array.isArray(value) ? value : value ? Number(value) : value;
-    },
-    optionLabel: function (value) {
-        var _a;
-        return Array.isArray(value)
-            ? "[".concat(value.join(","), "]")
-            : ((_a = value === null || value === undefined ? undefined : value.toLocaleString(DEFAULT_LOCALE)) !== null && _a !== undefined ? _a : "");
-    },
-});
-createBuiltInType("boolean", {
-    transform: function (value) { return value === "true" || value === true; },
-    optionLabel: function (value) { return (value ? "true" : "false"); },
-});
-createBuiltInType("time", {
-    transform: function (value) {
-        var date = (value === null || value === undefined ? undefined : value.date) ? new Date(value.date) : undefined;
-        var isValid = date && date.toString() !== "Invalid Date";
-        return {
-            date: isValid ? date : undefined,
-            relativeTimeString: value === null || value === undefined ? undefined : value.relativeTimeString,
-        };
-    },
-    optionLabel: function (value) {
-        var _a, _b;
-        if (!value)
-            return "";
-        if (value === null || value === undefined ? undefined : value.date) {
-            return ((_b = (_a = value.date) === null || _a === undefined ? undefined : _a.toLocaleDateString(DEFAULT_LOCALE)) !== null && _b !== undefined ? _b : value.date.toLocaleString());
-        }
-        return value.relativeTimeString;
-    },
-});
-createBuiltInType("timeRange", {
-    transform: function (value) {
-        // Return undefined instead of a null populated object
-        if (!value)
-            return undefined;
-        var _a = [value === null || value === undefined ? undefined : value.from, value === null || value === undefined ? undefined : value.to], from = _a[0], to = _a[1];
-        var fromDate = new Date(from);
-        var toDate = new Date(to);
-        return {
-            from: fromDate.toString() !== "Invalid Date" ? fromDate : undefined,
-            to: toDate.toString() !== "Invalid Date" ? toDate : undefined,
-            relativeTimeString: value === null || value === undefined ? undefined : value.relativeTimeString,
-        };
-    },
-    optionLabel: function (value) {
-        var _a, _b, _c, _d, _e, _f;
-        if (!value)
-            return "";
-        if ((value === null || value === undefined ? undefined : value.from) && (value === null || value === undefined ? undefined : value.to)) {
-            return "".concat((_b = (_a = value.from) === null || _a === undefined ? undefined : _a.toLocaleDateString(DEFAULT_LOCALE)) !== null && _b !== undefined ? _b : (_c = value.from) === null || _c === undefined ? undefined : _c.toLocaleString(), ",").concat((_e = (_d = value.to) === null || _d === undefined ? undefined : _d.toLocaleDateString(DEFAULT_LOCALE)) !== null && _e !== undefined ? _e : (_f = value.to) === null || _f === undefined ? undefined : _f.toLocaleString());
-        }
-        return value === null || value === undefined ? undefined : value.relativeTimeString;
-    },
-});
-createBuiltInType("granularity", {
-    transform: function (value) { return value; },
-    optionLabel: function (value) { return value; },
-});
-createBuiltInType("dataset");
-createBuiltInType("measure");
-createBuiltInType("dimension");
-createBuiltInType("dimensionOrMeasure");
-
-const embeddableTypeSchema = zod.z
-    .object({
-    typeConfig: zod.z.object({
-        label: zod.z.string(),
-        toString: zod.z.function(),
-    }),
-})
-    .or(zod.z.enum(ALL_NATIVE_TYPES));
-
-const editorMetaSchema = zod.z
-    .object({
-    name: zod.z.string(),
-    label: zod.z.string(),
-    type: embeddableTypeSchema,
-    config: zod.z.object({}).optional(),
-})
-    .strict();
-
-const editorMetaValidator = (metaInfo) => {
-    const result = editorMetaSchema.safeParse(metaInfo.meta);
-    if (result.success)
-        return [];
-    return errorFormatter(result.error.issues);
-};
-
-const componentMetaSchema = zod.z
-    .object({
-    name: zod.z.string(),
-    label: zod.z.string(),
-    category: zod.z.string().optional(),
-    classNames: zod.z.string().array().min(1).optional(),
-    defaultWidth: zod.z.number().optional(),
-    defaultHeight: zod.z.number().optional(),
-    inputs: zod.z
-        .object({
-        name: zod.z.string(),
-        label: zod.z.string(),
-        description: zod.z.string().optional(),
-        defaultValue: zod.z.any().optional(),
-        config: zod.z.record(zod.z.string(), zod.z.any()).optional(),
-        type: embeddableTypeSchema,
-        array: zod.z.boolean().optional(),
-        category: zod.z.string().optional(),
-        required: zod.z.boolean().optional(),
-    })
-        .strict()
-        .array()
-        .superRefine((inputs, refinementContext) => {
-        const inputNames = inputs.map((input) => input.name);
-        if (new Set(inputNames).size !== inputNames.length) {
-            const duplicateInputNames = inputNames.filter((name, index) => inputNames.indexOf(name) !== index);
-            return refinementContext.addIssue({
-                code: zod.z.ZodIssueCode.custom,
-                message: `Input names must be unique. Duplicate names: ${duplicateInputNames.join(", ")}`,
-            });
-        }
-    })
-        .optional(),
-    events: zod.z
-        .object({
-        name: zod.z.string(),
-        label: zod.z.string(),
-        properties: zod.z
-            .object({
-            name: zod.z.string(),
-            type: embeddableTypeSchema,
-            array: zod.z.boolean().optional(),
-            label: zod.z.string().optional(),
-        })
-            .array()
-            .optional(),
-    })
-        .strict()
-        .array()
-        .optional(),
-    variables: zod.z
-        .object({
-        name: zod.z.string(),
-        type: embeddableTypeSchema,
-        array: zod.z.boolean().optional(),
-        defaultValue: zod.z.any().optional(),
-        inputs: zod.z.array(zod.z.string()).optional(),
-        events: zod.z
-            .array(zod.z.object({
-            name: zod.z.string(),
-            property: zod.z.string(),
-        }))
-            .optional(),
-    })
-        .strict()
-        .array()
-        .optional(),
-})
-    .strict()
-    .superRefine(({ defaultWidth, defaultHeight }, refinementContext) => {
-    const widthAndHeight = [defaultHeight, defaultWidth].filter(Boolean);
-    if (widthAndHeight.length === 1) {
-        return refinementContext.addIssue({
-            code: zod.z.ZodIssueCode.custom,
-            message: "both defaultWidth and defaultHeight must be set",
-            path: ["defaultWidth | defaultHeight"],
-        });
-    }
-});
-
-// @ts-ignore
-const babelTraverse = traverse.default;
-const parseAndTraverse = (code, visitor) => {
-    const ast = parser.parse(code || "", {
-        sourceType: "module",
-    });
-    babelTraverse(ast, visitor);
-};
-const componentMetaValidator = (metaInfo) => {
-    const result = componentMetaSchema.safeParse(metaInfo.meta);
-    if (!result.success)
-        return errorFormatter(result.error.issues);
-    let moduleNameErrors = validateModuleName(metaInfo);
-    const variableErrors = validateVariables(metaInfo.meta);
-    const eventErrors = validateComponentEvents(metaInfo);
-    const loadDataErrors = validateComponentProps(metaInfo);
-    return [
-        ...moduleNameErrors,
-        ...variableErrors,
-        ...eventErrors,
-        ...loadDataErrors,
-    ];
-};
-const validateComponentProps = (metaInfo) => {
-    const errors = [];
-    parseAndTraverse(metaInfo.moduleInfo.code, {
-        ExportDefaultDeclaration: (path) => {
-            var _a;
-            const componentConfig = path.node.declaration
-                .arguments[2];
-            const propsNode = (_a = componentConfig.properties) === null || _a === undefined ? undefined : _a.find((x) => { var _a; return ((_a = x.key) === null || _a === undefined ? undefined : _a.name) === "props"; });
-            // There is no props defined
-            if (!propsNode)
-                return;
-            // if propsNode is a function defined elsewhere
-            if (propsNode.value.type === "Identifier") {
-                const functionName = propsNode.value.name;
-                path
-                    .findParent((path) => path.isProgram())
-                    .traverse({
-                    VariableDeclarator(path) {
-                        if (path.node.id.name === functionName &&
-                            (path.node.init.type === "FunctionExpression" ||
-                                path.node.init.type === "ArrowFunctionExpression")) {
-                            path.node.init.body.body;
-                        }
-                    },
-                });
-            }
-            else {
-                // assume that propsNode is anonymous function
-                propsNode.value.body.body;
-            }
-        },
-    });
-    return errors;
-};
-const validateComponentEvents = (metaInfo) => {
-    var _a, _b;
-    const definedEvents = (_b = (_a = metaInfo.meta.events) === null || _a === undefined ? undefined : _a.map((e) => e.name)) !== null && _b !== undefined ? _b : [];
-    let implementedEvents = [];
-    const errors = [];
-    parseAndTraverse(metaInfo.moduleInfo.code, {
-        ExportDefaultDeclaration: (path) => {
-            var _a, _b, _c, _d;
-            const componentConfig = path.node.declaration
-                .arguments[2];
-            const eventsNode = (_a = componentConfig.properties) === null || _a === undefined ? undefined : _a.find((p) => { var _a; return ((_a = p.key) === null || _a === undefined ? undefined : _a.name) === "events"; });
-            implementedEvents =
-                (_d = (_c = (_b = eventsNode === null || eventsNode === undefined ? undefined : eventsNode.value) === null || _b === undefined ? undefined : _b.properties) === null || _c === undefined ? undefined : _c.map((p) => p.key.name)) !== null && _d !== undefined ? _d : [];
-        },
-    });
-    const definedEventsSet = new Set(definedEvents);
-    const implementedEventsSet = new Set(implementedEvents);
-    const notImplementedEvents = definedEvents.filter((e) => !implementedEventsSet.has(e));
-    const notDefinedEvents = implementedEvents.filter((e) => !definedEventsSet.has(e));
-    for (const notDefinedEvent of notDefinedEvents) {
-        errors.push(`event '${notDefinedEvent}' is not defined in the component's meta`);
-    }
-    for (const notImplementedEvent of notImplementedEvents) {
-        errors.push(`event '${notImplementedEvent}' is defined but not implemented`);
-    }
-    return errors;
-};
-const validateModuleName = (metaInfo) => {
-    const basename = path__namespace.basename(metaInfo.moduleId);
-    const fileName = basename.split(".")[0];
-    if (fileName !== metaInfo.meta.name) {
-        return [
-            `meta.name: The name of the .emb.* file and [meta.name]'s value must match. In this case, [meta.name] must be ${fileName}`,
-        ];
-    }
-    return [];
-};
-const validateVariables = (meta) => {
-    const variables = meta.variables;
-    if (!variables)
-        return [];
-    const errors = [];
-    // all inputs should be defined
-    errors.push(...validateVariableInputs(meta));
-    // all events and properties should be valid
-    errors.push(...validateVariableEvents(meta));
-    return errors;
-};
-const validateVariableInputs = (meta) => {
-    const variables = meta.variables;
-    const definedInputs = meta.inputs;
-    if (!variables)
-        return [];
-    const errors = [];
-    // all inputs should be defined
-    variables.forEach((variableConfig, idx) => {
-        const inputs = variableConfig.inputs;
-        if (inputs) {
-            inputs.forEach((input, inputIdx) => {
-                const definedInput = definedInputs === null || definedInputs === undefined ? undefined : definedInputs.find((d) => d.name === input);
-                if (!definedInput) {
-                    const path = formatErrorPath(["variables", idx, "inputs", inputIdx]);
-                    errors.push(`${path}: input "${input}" is not defined`);
-                }
-            });
-        }
-    });
-    return errors;
-};
-const validateVariableEvents = (meta) => {
-    const variables = meta.variables;
-    const definedEvents = meta.events;
-    if (!variables)
-        return [];
-    const errors = [];
-    variables.forEach((variableConfig, idx) => {
-        const events = variableConfig.events;
-        if (events) {
-            events.forEach((event, eventIdx) => {
-                const definedEvent = definedEvents === null || definedEvents === undefined ? undefined : definedEvents.find((d) => d.name === event.name);
-                if (!definedEvent) {
-                    const path = formatErrorPath([
-                        "variables",
-                        idx,
-                        "events",
-                        eventIdx,
-                        "name",
-                    ]);
-                    errors.push(`${path}: event "${event.name}" is not defined`);
-                    return;
-                }
-                const definedProperties = definedEvent.properties;
-                const definedProperty = definedProperties === null || definedProperties === undefined ? undefined : definedProperties.find((p) => p.name === event.property);
-                if (!definedProperty) {
-                    const path = formatErrorPath([
-                        "variables",
-                        idx,
-                        "events",
-                        eventIdx,
-                        "property",
-                    ]);
-                    errors.push(`${path}: property "${event.property}" is not defined`);
-                    return;
-                }
-                const path = formatErrorPath(["variables", idx]);
-                if (definedProperty.type !== variableConfig.type) {
-                    errors.push(`${path}: the type of the variable "${variableConfig.name}" and the type of the property "${event.property}" do not match`);
-                }
-                if (Boolean(definedProperty.array) !== Boolean(variableConfig.array)) {
-                    errors.push(`${path}: the array of the variable "${variableConfig.name}" and the array of the property "${event.property}" do not match`);
-                }
-            });
-        }
-    });
-    return errors;
-};
-
-const EDITOR = "editor";
-const COMPONENT = "component";
-const validators = {
-    [EDITOR]: editorMetaValidator,
-    [COMPONENT]: componentMetaValidator,
-};
-const getModuleType = (moduleInfo) => {
-    var _a, _b;
-    if ((_a = moduleInfo.code) === null || _a === undefined ? undefined : _a.includes("defineComponent")) {
-        return COMPONENT;
-    }
-    else if ((_b = moduleInfo.code) === null || _b === undefined ? undefined : _b.includes("defineEditor")) {
-        return EDITOR;
-    }
-    else {
-        return null;
-    }
-};
-var validateComponentMetaPlugin = (componentFileRegex) => {
-    let metaConfigs = [];
-    return {
-        name: "validate-component-meta",
-        moduleParsed: async (moduleInfo) => {
-            const moduleType = componentFileRegex.test(moduleInfo.id)
-                ? getModuleType(moduleInfo)
-                : null;
-            if (moduleType) {
-                const meta = await loadComponentMeta(moduleInfo.id);
-                metaConfigs.push({
-                    moduleId: moduleInfo.id,
-                    meta,
-                    moduleType,
-                    moduleInfo,
-                });
-            }
-        },
-        buildEnd: function () {
-            const errors = [];
-            for (const metaConfig of metaConfigs) {
-                const validator = validators[metaConfig.moduleType];
-                const validationResult = validator(metaConfig);
-                if (validationResult && validationResult.length) {
-                    errors.push(`\nComponent meta is not valid ${metaConfig.moduleId}:\n${validationResult.join("\n")}`);
-                }
-            }
-            metaConfigs = [];
-            if (errors.length) {
-                // @ts-ignore
-                this.error(errors.join("\n"));
-            }
-        },
-    };
-};
-
-/**
- * Modifies entry point only if there is 'styled-components' in the client's package.json.
- * Imports StyleSheetManager from styled-components and adds shadow root as "target".
- * That will force styled-components to add classes to the customers web-component
- * see https://styled-components.com/docs/api#stylesheetmanager
- */
-const styledComponentsEntrypointModifier = {
-    getContentBegin() {
-        return "<StyleSheetManager target={rootEl.getRootNode()}>";
-    },
-    getContentEnd() {
-        return "</StyleSheetManager>";
-    },
-    getImports() {
-        return "import {StyleSheetManager} from 'styled-components'";
-    },
-    needToModify(ctx) {
-        var _a;
-        const packageJsonFilePath = path__namespace.resolve(ctx.client.rootDir, "package.json");
-        const packageJson = require(packageJsonFilePath);
-        return !!((_a = packageJson.dependencies) === null || _a === undefined ? undefined : _a["styled-components"]);
-    },
-};
-
-const entrypointModifiers = [
-    styledComponentsEntrypointModifier,
-];
-
-function findFilesWithWrongUsage(directory, pattern, mustEndWith = []) {
-    const files = fs__namespace$1.readdirSync(directory);
-    const result = [];
-    files.forEach((file) => {
-        const filePath = path__namespace.join(directory, file);
-        if (fs__namespace$1.statSync(filePath).isDirectory()) {
-            // Recursively check files in subdirectories
-            result.push(...findFilesWithWrongUsage(filePath, pattern, mustEndWith));
-        }
-        else {
-            const fileContent = fs__namespace$1.readFileSync(filePath, "utf8");
-            if (fileContent.match(pattern)) {
-                result.push(filePath);
-            }
-        }
-    });
-    return result.filter((file) => !mustEndWith.some((ending) => file.endsWith(ending)));
-}
-function findTypeNames(directory) {
-    const files = fs__namespace$1.readdirSync(directory);
-    const typeNames = [];
-    files.forEach((file) => {
-        const filePath = path__namespace.join(directory, file);
-        if (fs__namespace$1.statSync(filePath).isDirectory()) {
-            // Recursively check files in subdirectories
-            typeNames.push(...findTypeNames(filePath));
-        }
-        else {
-            const fileContent = fs__namespace$1.readFileSync(filePath, "utf8");
-            const regexDefineTypeFunctionTypeName = /defineType\(["'](.*?)["']\,/g;
-            const matches = fileContent.match(regexDefineTypeFunctionTypeName) || [];
-            const extractedContent = matches.map((match) => match.slice(12, -2))[0];
-            if (extractedContent) {
-                typeNames.push({ file: filePath, typeName: extractedContent });
-            }
-        }
-    });
-    return typeNames;
-}
-const regexDefineComponentFunction = /defineComponent(<\w+>)?\(/;
-const regexDefineTypeFunction = /defineType\(/;
-const regexDefineOptionFunction = /defineOption\(/;
-const regexCubeFunction = /cube\(/;
-const regexCubes = /cubes:/;
-const usageValidator = async (directory) => {
-    let isValid = true;
-    const progress = ora("React: function usage validating...").start();
-    // defineComponent function
-    const filesWithWrongDefineComponentFunctionUsage = findFilesWithWrongUsage(directory, regexDefineComponentFunction, [".emb.js", ".emb.ts"]);
-    if (filesWithWrongDefineComponentFunctionUsage.length) {
-        isValid = false;
-        progress.fail("React: defineComponent() usage is only allowed inside files with the extension .emb.(js|ts) files.\nFix the following files:\n" +
-            filesWithWrongDefineComponentFunctionUsage.join("\n"));
-    }
-    // defineType function
-    const filesWithWrongDefineTypeFunctionUsage = findFilesWithWrongUsage(directory, regexDefineTypeFunction, [".type.emb.js", ".type.emb.ts"]);
-    if (filesWithWrongDefineTypeFunctionUsage.length) {
-        isValid = false;
-        progress.fail("React: defineType() usage is only allowed inside files with the extension .type.emb.(js|ts) files.\nFix the following files:\n" +
-            filesWithWrongDefineTypeFunctionUsage.join("\n"));
-    }
-    // defineOption function
-    const filesWithWrongDefineOptionFunctionUsage = findFilesWithWrongUsage(directory, regexDefineOptionFunction, [".type.emb.js", ".type.emb.ts"]);
-    if (filesWithWrongDefineOptionFunctionUsage.length) {
-        isValid = false;
-        progress.fail("React: defineOption() usage is only allowed inside files with the extension .type.emb.(js|ts) files.\nFix the following files:\n" +
-            filesWithWrongDefineOptionFunctionUsage.join("\n"));
-    }
-    // cube function
-    const filesWithWrongCubeFunctionUsage = findFilesWithWrongUsage(directory, regexCubeFunction, [".cube.js", ".cube.ts"]);
-    if (filesWithWrongCubeFunctionUsage.length) {
-        isValid = false;
-        progress.fail("React: cube() usage is only allowed inside files with the extension .cube.(ts|js) files.\nFix the following files:\n" +
-            filesWithWrongCubeFunctionUsage.join("\n"));
-    }
-    // cube in yml or yaml files
-    const filesWithWrongCubeUsage = findFilesWithWrongUsage(directory, regexCubes, [".cube.yml", ".cube.yaml"]);
-    if (filesWithWrongCubeUsage.length) {
-        isValid = false;
-        progress.fail("React: cubes: usage is only allowed inside files with the extension .cube.(yml|yaml) files.\nFix the following files:\n" +
-            filesWithWrongCubeUsage.join("\n"));
-    }
-    const typeNames = findTypeNames(directory);
-    // check for definedTypes using a native typeNames
-    const duplicatedNativeTypeNames = typeNames.filter((item) => ALL_NATIVE_TYPES.includes(item.typeName));
-    if (duplicatedNativeTypeNames.length) {
-        isValid = false;
-        progress.fail("React: defineType() can't be used with the same typeName as the nativeTypes. Fix the following files:\n" +
-            duplicatedNativeTypeNames
-                .map((dtn) => `${dtn.typeName} (file: ${dtn.file})`)
-                .join("\n"));
-    }
-    // check for duplicated typeNames
-    const duplicatedTypeNames = typeNames.filter((item, index) => {
-        return typeNames.some((otherItem, otherIndex) => {
-            if (index !== otherIndex) {
-                return item.typeName === otherItem.typeName;
-            }
-            return false;
-        });
-    });
-    if (duplicatedTypeNames.length) {
-        isValid = false;
-        progress.fail("React: defineType() must be used with a unique typeName. Fix the following files:\n" +
-            duplicatedTypeNames
-                .map((dtn) => `${dtn.typeName} (file: ${dtn.file})`)
-                .join("\n"));
-    }
-    isValid
-        ? progress.succeed("React: function usage validated")
-        : process.exit(1);
-};
-
-const EMB_FILE_REGEX = /^(.*)(?<!\.type|\.options)\.emb\.[jt]s$/;
-var generate = async (ctx) => {
-    var _a;
-    await usageValidator(ctx.client.srcDir);
-    const filesList = await findFiles(ctx.client.srcDir, EMB_FILE_REGEX);
-    await prepareEntrypoint(ctx, filesList);
-    let result;
-    if ((_a = ctx.dev) === null || _a === undefined ? undefined : _a.watch) {
-        result = await runViteWatch(ctx);
-    }
-    else {
-        const progress = ora("React: building components...").start();
-        result = await runViteBuild(ctx);
-        progress.succeed("Building React components completed");
-    }
-    return result;
-};
-async function runViteBuild(ctx, watch = null) {
-    var _a;
-    return await vite__namespace.build({
-        logLevel: !!watch ? "info" : "error",
-        resolve: {
-            extensions: [".ts", ".tsx", ".js", ".jsx", ".json"],
-            ...(_a = ctx.client.viteConfig) === null || _a === undefined ? undefined : _a.resolve,
-        },
-        plugins: [
-            viteReactPlugin(),
-            extractComponentsConfigPlugin({
-                isDev: !!watch,
-                globalKey: "componentsMeta",
-                fileName: "embeddable-components-meta.js",
-                outputDir: ctx.client.buildDir,
-                componentFileRegex: EMB_FILE_REGEX,
-                searchEntry: "defineComponent",
-            }),
-            extractComponentsConfigPlugin({
-                isDev: !!watch,
-                globalKey: "editorsMeta",
-                fileName: "embeddable-editors-meta.js",
-                outputDir: ctx.client.buildDir,
-                componentFileRegex: EMB_FILE_REGEX,
-                searchEntry: "defineEditor",
-            }),
-            validateComponentMetaPlugin(EMB_FILE_REGEX),
-        ],
-        build: {
-            sourcemap: true,
-            watch: watch
-                ? {
-                    include: [ctx.client.srcDir + "/**"],
-                    exclude: ["**/node_modules/**"],
-                }
-                : undefined,
-            minify: !watch,
-            rollupOptions: watch
-                ? {
-                    cache: true,
-                    ...ctx.client.rollupOptions,
-                    output: {
-                        sourcemapPathTransform: (relativeSourcePath, sourcemapPath) => {
-                            // will replace relative paths with absolute paths
-                            return path__namespace.resolve(path__namespace.dirname(sourcemapPath), relativeSourcePath);
-                        },
-                    },
-                }
-                : ctx.client.rollupOptions,
-            lib: {
-                entry: path__namespace.resolve(ctx.client.buildDir, ctx["sdk-react"].outputOptions.componentsEntryPointFilename),
-                formats: ["es"],
-                fileName: ctx["sdk-react"].outputOptions.fileName,
-            },
-            outDir: path__namespace.resolve(ctx.client.buildDir, ctx["sdk-react"].outputOptions.buildName),
-        },
-        define: {
-            "process.env.NODE_ENV": `${watch ? '"development"' : '"production"'}`,
-        },
-    });
-}
-async function runViteWatch(ctx) {
-    const watch = {
-        chokidar: {
-            ignored: ["**/node_modules/**", /.*\.emb-temp.js$/, /.*\.cube.js$/],
-        },
-    };
-    return (await runViteBuild(ctx, watch));
-}
-const IMPORT_REPLACE_TOKEN = "{{LAZY_IMPORTS}}";
-const ERROR_FALLBACK_COMPONENT_IMPORT_TOKEN = "{{ERROR_FALLBACK_COMPONENT_IMPORT}}";
-const ERROR_FALLBACK_COMPONENT_TOKEN = "{{ERROR_FALLBACK_COMPONENT}}";
-const ERROR_FALLBACK_COMPONENT_DEFAULT_NAME = "ErrorFallbackComponent";
-const ADDITIONAL_CONTENT_IMPORT_TOKEN = "{{ADDITIONAL_CONTENT_IMPORT}}";
-const ADDITIONAL_CONTENT_BEGIN_TOKEN = "{{ADDITIONAL_CONTENT_BEGIN}}";
-const ADDITIONAL_CONTENT_END_TOKEN = "{{ADDITIONAL_CONTENT_END}}";
-function getRelativeFileNameForImport(ctx, fileName) {
-    return `../${path__namespace
-        .relative(ctx.client.rootDir, fileName)
-        // it is a bit of a hack. On windows the path will look like '.src\something\something'
-        // but for imports it must be '.src/something/something'
-        .replaceAll("\\", "/")}`;
-}
-async function prepareEntrypoint(ctx, filesList) {
-    const imports = filesList
-        .map(([fileName, filePath]) => `\t${fileName}: React.lazy(() => import('${getRelativeFileNameForImport(ctx, filePath)}'))`)
-        .join(",\n");
-    let errorBoundaryImport = "";
-    let errorFallbackComponent = "null";
-    if (ctx.client.errorFallbackComponent) {
-        errorBoundaryImport = `import ${ERROR_FALLBACK_COMPONENT_DEFAULT_NAME} from '${getRelativeFileNameForImport(ctx, ctx.client.errorFallbackComponent)}';`;
-        errorFallbackComponent = ERROR_FALLBACK_COMPONENT_DEFAULT_NAME;
-    }
-    const additionalContentImport = [];
-    let additionalContentBegin = [];
-    let additionalContentEnd = [];
-    for (const entrypointModifier of entrypointModifiers) {
-        if (entrypointModifier.needToModify(ctx)) {
-            additionalContentImport.push(entrypointModifier.getImports(ctx));
-            additionalContentBegin.push(entrypointModifier.getContentBegin(ctx));
-            additionalContentEnd.unshift(entrypointModifier.getContentEnd(ctx));
-        }
-    }
-    const content = await fs__namespace$2.readFile(path__namespace.resolve(ctx["sdk-react"].templatesDir, `${ctx["sdk-react"].outputOptions.componentsEntryPointFilename}.template`), "utf8");
-    await fs__namespace$2.writeFile(path__namespace.resolve(ctx.client.buildDir, ctx["sdk-react"].outputOptions.componentsEntryPointFilename), content
-        .replace(IMPORT_REPLACE_TOKEN, imports)
-        .replace(ERROR_FALLBACK_COMPONENT_IMPORT_TOKEN, errorBoundaryImport)
-        .replace(ERROR_FALLBACK_COMPONENT_TOKEN, errorFallbackComponent)
-        .replace(ADDITIONAL_CONTENT_IMPORT_TOKEN, additionalContentImport.join("\n"))
-        .replace(ADDITIONAL_CONTENT_BEGIN_TOKEN, additionalContentBegin.join("\n"))
-        .replace(ADDITIONAL_CONTENT_END_TOKEN, additionalContentEnd.join("\n")));
-}
-
-var build = async (ctx) => {
-    createContext(path__namespace$1.resolve(__dirname, ".."), ctx);
-    return generate(ctx);
-};
-
-var cleanup = async (ctx) => {
-    await fs.rm(path.resolve(ctx.client.buildDir, ctx["sdk-react"].outputOptions.componentsEntryPointFilename));
-};
-
-var index = () => {
-    return {
-        pluginName: "sdk-react",
-        validate: async () => { },
-        build,
-        cleanup,
-    };
-};
-
-module.exports = index;
-//# sourceMappingURL=index.js.map