smbls 3.2.3 → 3.2.8

package/dist/cjs/src/prepare.js

@@ -0,0 +1,296 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var prepare_exports = {};
+__export(prepare_exports, {
+  PACKAGE_MANAGER_TO_CDN: () => PACKAGE_MANAGER_TO_CDN,
+  getCDNUrl: () => getCDNUrl,
+  getCdnProviderFromConfig: () => getCdnProviderFromConfig,
+  prepareComponents: () => prepareComponents,
+  prepareDependencies: () => prepareDependencies,
+  prepareDesignSystem: () => prepareDesignSystem,
+  prepareMethods: () => prepareMethods,
+  preparePages: () => preparePages,
+  prepareRequire: () => prepareRequire,
+  prepareSharedLibs: () => prepareSharedLibs,
+  prepareState: () => prepareState,
+  prepareUtils: () => prepareUtils,
+  prepareWindow: () => prepareWindow
+});
+module.exports = __toCommonJS(prepare_exports);
+var import_utils = require("@domql/utils");
+var import_emotion = require("@symbo.ls/emotion");
+var uikit = __toESM(require("@symbo.ls/uikit"), 1);
+var utils = __toESM(require("./utilImports.js"), 1);
+var routerUtils = __toESM(require("@domql/router"), 1);
+// @preserve-env
+const prepareWindow = (context) => {
+  if (typeof window === "undefined") window = globalThis || {};
+  if (typeof document === "undefined") {
+    if (!window.document) window.document = globalThis.document || { body: {} };
+    document = window.document;
+  }
+  context.document = context.document || document;
+  context.window = context.window || window;
+  return context.window;
+};
+function onlyDotsAndNumbers(str) {
+  return /^[0-9.]+$/.test(str) && str !== "";
+}
+const CDN_PROVIDERS = {
+  skypack: {
+    url: "https://cdn.skypack.dev",
+    formatUrl: (pkg, version) => `${CDN_PROVIDERS.skypack.url}/${pkg}${version !== "latest" ? `@${version}` : ""}`
+  },
+  esmsh: {
+    url: "https://esm.sh",
+    formatUrl: (pkg, version) => `${CDN_PROVIDERS.esmsh.url}/${pkg}${version !== "latest" ? `@${version}` : ""}`
+  },
+  unpkg: {
+    url: "https://unpkg.com",
+    formatUrl: (pkg, version) => `${CDN_PROVIDERS.unpkg.url}/${pkg}${version !== "latest" ? `@${version}` : ""}?module`
+  },
+  jsdelivr: {
+    url: "https://cdn.jsdelivr.net/npm",
+    formatUrl: (pkg, version) => `${CDN_PROVIDERS.jsdelivr.url}/${pkg}${version !== "latest" ? `@${version}` : ""}/+esm`
+  },
+  symbols: {
+    url: "https://pkg.symbo.ls",
+    formatUrl: (pkg, version) => {
+      if (pkg.split("/").length > 2 || !onlyDotsAndNumbers(version)) {
+        return `${CDN_PROVIDERS.symbols.url}/${pkg}`;
+      }
+      return `${CDN_PROVIDERS.symbols.url}/${pkg}/${version}.js`;
+    }
+  }
+};
+const PACKAGE_MANAGER_TO_CDN = {
+  "esm.sh": "esmsh",
+  "unpkg": "unpkg",
+  "skypack": "skypack",
+  "jsdelivr": "jsdelivr",
+  "pkg.symbo.ls": "symbols"
+};
+const getCdnProviderFromConfig = (symbolsConfig = {}) => {
+  const { packageManager } = symbolsConfig;
+  return PACKAGE_MANAGER_TO_CDN[packageManager] || null;
+};
+const getCDNUrl = (packageName, version = "latest", provider = "esmsh") => {
+  const cdnConfig = CDN_PROVIDERS[provider] || CDN_PROVIDERS.esmsh;
+  return cdnConfig.formatUrl(packageName, version);
+};
+const UIkitWithPrefix = (prefix = "smbls") => {
+  const newObj = {};
+  for (const key in uikit) {
+    if (Object.prototype.hasOwnProperty.call(uikit, key)) {
+      if ((0, import_utils.matchesComponentNaming)(key)) {
+        newObj[`smbls.${key}`] = uikit[key];
+      } else {
+        newObj[key] = uikit[key];
+      }
+    }
+  }
+  return newObj;
+};
+const prepareComponents = (context) => {
+  return context.components ? { ...UIkitWithPrefix(), ...context.components } : UIkitWithPrefix();
+};
+const prepareUtils = (context) => {
+  return {
+    ...utils,
+    ...routerUtils,
+    ...utils.scratchUtils,
+    ...context.utils,
+    ...context.snippets,
+    ...context.functions
+  };
+};
+const prepareMethods = (context) => {
+  return {
+    ...context.methods || {},
+    require: context.utils.require,
+    requireOnDemand: context.utils.requireOnDemand,
+    router: context.utils.router
+  };
+};
+const cachedDeps = {};
+const prepareDependencies = async ({
+  dependencies,
+  dependenciesOnDemand,
+  document: document2,
+  preventCaching = false,
+  cdnProvider,
+  packageManager,
+  symbolsConfig
+}) => {
+  if (!cdnProvider) {
+    cdnProvider = PACKAGE_MANAGER_TO_CDN[packageManager] || getCdnProviderFromConfig(symbolsConfig) || "esmsh";
+  }
+  if (!dependencies) return null;
+  let hasAny = false;
+  for (const _k in dependencies) {
+    hasAny = true;
+    break;
+  }
+  if (!hasAny) return null;
+  for (const dependency in dependencies) {
+    const version = dependencies[dependency];
+    if (dependenciesOnDemand && dependenciesOnDemand[dependency]) {
+      continue;
+    }
+    const random = (0, import_utils.isDevelopment)() && preventCaching ? `?${Math.random()}` : "";
+    const url = getCDNUrl(dependency, version, cdnProvider) + random;
+    try {
+      if (cachedDeps[dependency]) return;
+      cachedDeps[dependency] = true;
+      await utils.loadRemoteScript(url, { document: document2, type: "module" });
+    } catch (e) {
+      console.error(`Failed to load ${dependency} from ${cdnProvider}:`, e);
+      if (cdnProvider !== "symbols") {
+        try {
+          const fallbackUrl = getCDNUrl(dependency, version, "symbols") + random;
+          await utils.loadRemoteScript(fallbackUrl, { document: document2 });
+          console.log(
+            `Successfully loaded ${dependency} from fallback (symbols.ls)`
+          );
+        } catch (fallbackError) {
+          console.error(
+            `Failed to load ${dependency} from fallback:`,
+            fallbackError
+          );
+        }
+      }
+    }
+  }
+  return dependencies;
+};
+const prepareRequire = async (packages, ctx) => {
+  const windowOpts = ctx.window || window;
+  const defaultProvider = ctx.cdnProvider || getCdnProviderFromConfig(ctx.symbolsConfig) || "esmsh";
+  const initRequire = async (ctx2) => async (key, provider) => {
+    const windowOpts2 = ctx2.window || window;
+    const pkg = windowOpts2.packages[key];
+    if (typeof pkg === "function") return pkg();
+    return pkg;
+  };
+  const initRequireOnDemand = async (ctx2) => async (key, provider = defaultProvider) => {
+    const { dependenciesOnDemand } = ctx2;
+    const documentOpts = ctx2.document || document;
+    const windowOpts2 = ctx2.window || window;
+    if (!windowOpts2.packages[key]) {
+      const random = (0, import_utils.isDevelopment)() ? `?${Math.random()}` : "";
+      if (dependenciesOnDemand && dependenciesOnDemand[key]) {
+        const version = dependenciesOnDemand[key];
+        const url = getCDNUrl(key, version, provider) + random;
+        try {
+          await ctx2.utils.loadRemoteScript(url, {
+            window: windowOpts2,
+            document: documentOpts
+          });
+        } catch (e) {
+          console.error(`Failed to load ${key} from ${provider}:`, e);
+          if (provider !== "symbols") {
+            const fallbackUrl = getCDNUrl(key, version, "symbols") + random;
+            await ctx2.utils.loadRemoteScript(fallbackUrl, {
+              window: windowOpts2,
+              document: documentOpts
+            });
+          }
+        }
+      } else {
+        const url = getCDNUrl(key, "latest", provider) + random;
+        try {
+          await ctx2.utils.loadRemoteScript(url, {
+            window: windowOpts2,
+            document: documentOpts
+          });
+        } catch (e) {
+          console.error(`Failed to load ${key} from ${provider}:`, e);
+          if (provider !== "symbols") {
+            const fallbackUrl = getCDNUrl(key, "latest", "symbols") + random;
+            await ctx2.utils.loadRemoteScript(fallbackUrl, {
+              window: windowOpts2,
+              document: documentOpts
+            });
+          }
+        }
+        windowOpts2.packages[key] = "loadedOnDeman";
+      }
+    }
+    return await windowOpts2.require(key, provider);
+  };
+  if (windowOpts.packages) {
+    windowOpts.packages = (0, import_utils.merge)(windowOpts.packages, packages);
+  } else {
+    windowOpts.packages = packages;
+  }
+  if (!windowOpts.require) {
+    ctx.utils.require = await initRequire(ctx);
+    windowOpts.require = ctx.utils.require;
+  }
+  if (!windowOpts.requireOnDemand) {
+    ctx.utils.requireOnDemand = await initRequireOnDemand(ctx);
+    windowOpts.requireOnDemand = ctx.utils.requireOnDemand;
+  }
+};
+const prepareDesignSystem = (key, context) => {
+  const [scratcDesignhSystem, emotion, registry] = (0, import_emotion.initEmotion)(key, context);
+  return [scratcDesignhSystem, emotion, registry];
+};
+const prepareState = (app, context) => {
+  const state = {};
+  if (context.state) utils.deepMerge(state, context.state);
+  if (app && app.state) (0, import_utils.deepMerge)(state, app.state);
+  state.isRootState = true;
+  return (0, import_utils.deepClone)(state);
+};
+const preparePages = (app, context) => {
+  if ((0, import_utils.isObject)(app.routes) && (0, import_utils.isObject)(context.pages)) {
+    (0, import_utils.merge)(app.routes, context.pages);
+  }
+  const pages = app.routes || context.pages || {};
+  for (const v in pages) {
+    if (v.charCodeAt(0) === 47) continue;
+    const index = v === "index" ? "" : v;
+    pages["/" + index] = pages[v];
+    delete pages[v];
+  }
+  return pages;
+};
+const prepareSharedLibs = (context) => {
+  const sharedLibraries = context.sharedLibraries;
+  for (let i = 0; i < sharedLibraries.length; i++) {
+    const sharedLib = sharedLibraries[i];
+    if (context.type === "template") {
+      overwriteShallow(context.designSystem, sharedLib.designSystem);
+      (0, import_utils.deepMerge)(context, sharedLib, ["designSystem"], 1);
+    } else {
+      (0, import_utils.deepMerge)(context, sharedLib, [], 1);
+    }
+  }
+};

package/dist/cjs/src/router.js

@@ -0,0 +1,84 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var router_exports = {};
+__export(router_exports, {
+  initRouter: () => initRouter,
+  injectRouterInLinkComponent: () => injectRouterInLinkComponent,
+  onpopstateRouter: () => onpopstateRouter
+});
+module.exports = __toCommonJS(router_exports);
+var import_utils = require("@domql/utils");
+var import_router = require("@domql/router");
+var import_smbls = require("smbls");
+const DEFAULT_ROUTING_OPTIONS = {
+  initRouter: true,
+  injectRouterInLinkComponent: true,
+  popState: true
+};
+const initRouter = (element, context) => {
+  if (context.router === false) return;
+  else if (context.router === true) context.router = DEFAULT_ROUTING_OPTIONS;
+  else context.router = (0, import_utils.merge)(context.router || {}, DEFAULT_ROUTING_OPTIONS);
+  const routerOptions = context.router;
+  const onRouterRenderDefault = async (el, s) => {
+    const { pathname, search, hash } = import_utils.window.location;
+    const url = pathname + search + hash;
+    if (el.routes) await (0, import_router.router)(url, el, {}, { initialRender: true });
+  };
+  const hasRenderRouter = element.on && !(0, import_utils.isUndefined)(element.on.renderRouter) || !(0, import_utils.isUndefined)(element.onRenderRouter);
+  if (routerOptions && routerOptions.initRouter && !hasRenderRouter) {
+    if (element.on) {
+      element.on.renderRouter = onRouterRenderDefault;
+    } else {
+      element.on = {
+        renderRouter: onRouterRenderDefault
+      };
+    }
+  }
+  injectRouterInLinkComponent(context, routerOptions);
+  return routerOptions;
+};
+let popStateFired;
+const onpopstateRouter = (element, context) => {
+  if (popStateFired) return;
+  popStateFired = true;
+  const routerOptions = context.router || DEFAULT_ROUTING_OPTIONS;
+  if (!routerOptions.popState) return;
+  const router = context.utils && context.utils.router ? context.utils.router : import_router.router;
+  import_utils.window.onpopstate = async (e) => {
+    const { pathname, search, hash } = import_utils.window.location;
+    const url = pathname + search + hash;
+    await element.call(
+      "router",
+      url,
+      element,
+      {},
+      { pushState: false, scrollToTop: false, level: 0, event: e }
+    );
+  };
+};
+const injectRouterInLinkComponent = (context, routerOptions) => {
+  const { components } = context;
+  if (routerOptions && routerOptions.injectRouterInLinkComponent) {
+    return (0, import_utils.deepMerge)(
+      components["Link"] || components["smbls.Link"],
+      components["RouterLink"] || components["smbls.RouterLink"]
+    );
+  }
+};

package/dist/cjs/src/syncExtend.js

@@ -0,0 +1,70 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var syncExtend_exports = {};
+__export(syncExtend_exports, {
+  initializeExtend: () => initializeExtend,
+  initializeInspect: () => initializeInspect,
+  initializeNotifications: () => initializeNotifications,
+  initializeSync: () => initializeSync
+});
+module.exports = __toCommonJS(syncExtend_exports);
+var import_utils = require("@domql/utils");
+var import_sync = require("@symbo.ls/sync");
+const initializeExtend = (app, ctx) => {
+  return (0, import_utils.isObjectLike)(app.extends) ? app.extends : [];
+};
+const initializeSync = (app, ctx) => {
+  const { editor } = ctx;
+  if (!editor) return;
+  const liveSync = (0, import_utils.isUndefined)(editor.liveSync) ? (0, import_utils.isDevelopment)() : editor.liveSync;
+  if (liveSync) {
+    if ((0, import_utils.isArray)(app.extends)) app.extends.push(import_sync.SyncComponent);
+    else if (app.extends) {
+      app.extends = [app.extends, import_sync.SyncComponent];
+    } else {
+      app.extends = [import_sync.SyncComponent];
+    }
+  }
+};
+const initializeInspect = (app, ctx) => {
+  const { editor } = ctx;
+  if (!editor) return;
+  const inspect = (0, import_utils.isUndefined)(editor.inspect) ? (0, import_utils.isDevelopment)() : editor.inspect;
+  if (inspect) {
+    if ((0, import_utils.isArray)(app.extends)) app.extends.push(import_sync.Inspect);
+    else if (app.extends) {
+      app.extends = [app.extends, import_sync.Inspect];
+    } else {
+      app.extends = [import_sync.Inspect];
+    }
+  }
+};
+const initializeNotifications = (app, ctx) => {
+  const { editor } = ctx;
+  if (!editor) return;
+  const verbose = (0, import_utils.isUndefined)(editor.verbose) ? (0, import_utils.isDevelopment)() || ctx.verbose : editor.verbose;
+  if (verbose) {
+    if ((0, import_utils.isArray)(app.extends)) app.extends.push(import_sync.Notifications);
+    else if (app.extends) {
+      app.extends = [app.extends, import_sync.Notifications];
+    } else {
+      app.extends = [import_sync.Notifications];
+    }
+  }
+};

package/dist/cjs/src/utilImports.js

@@ -0,0 +1,35 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utilImports_exports = {};
+__export(utilImports_exports, {
+  applyCSS: () => import_init.applyCSS,
+  init: () => import_init.init,
+  reinit: () => import_init.reinit,
+  scratchSystem: () => import_scratch.scratchSystem,
+  scratchUtils: () => import_scratch.scratchUtils,
+  set: () => import_scratch.set
+});
+module.exports = __toCommonJS(utilImports_exports);
+var import_scratch = require("@symbo.ls/scratch");
+__reExport(utilImports_exports, require("@domql/utils"), module.exports);
+__reExport(utilImports_exports, require("@symbo.ls/smbls-utils"), module.exports);
+var import_init = require("./init.js");
+__reExport(utilImports_exports, require("@domql/report"), module.exports);
+__reExport(utilImports_exports, require("@domql/router"), module.exports);

package/dist/esm/index.js

@@ -1,10 +1,9 @@
 export * from "@domql/utils";
 export * from "attrs-in-props";
-export * from "@symbo.ls/create";
 export * from "css-in-props";
 export * from "@symbo.ls/default-config";
 export * from "@symbo.ls/emotion";
-export * from "@symbo.ls/init";
 export * from "@symbo.ls/scratch";
 export * from "@symbo.ls/uikit";
-export * from "@symbo.ls/utils";
+export * from "@symbo.ls/smbls-utils";
+export * from "./src/index.js";

package/dist/esm/src/createDomql.js

@@ -0,0 +1,96 @@
+import DOM from "domql";
+import * as uikit from "@symbo.ls/uikit";
+import { CSS_PROPS_REGISTRY } from "css-in-props";
+import { isString, isNode, isObject } from "@domql/utils";
+import { initAnimationFrame } from "@domql/element";
+import { defaultDefine } from "./define.js";
+import { initRouter } from "./router.js";
+import {
+  initializeExtend,
+  initializeNotifications,
+  initializeSync
+} from "./syncExtend.js";
+import {
+  prepareComponents,
+  prepareDependencies,
+  prepareDesignSystem,
+  prepareWindow,
+  prepareRequire,
+  preparePages,
+  prepareState,
+  prepareUtils,
+  prepareMethods,
+  prepareSharedLibs,
+  PACKAGE_MANAGER_TO_CDN
+} from "./prepare.js";
+const prepareContext = async (app, context = {}) => {
+  const key = context.key = context.key || (isString(app) ? app : "smblsapp");
+  context.define = context.define || defaultDefine;
+  context.cssPropsRegistry = CSS_PROPS_REGISTRY;
+  context.window = prepareWindow(context);
+  if (context.sharedLibraries && context.sharedLibraries.length) {
+    prepareSharedLibs(context);
+  }
+  const [scratcDesignSystem, emotion, registry] = prepareDesignSystem(
+    key,
+    context
+  );
+  context.designSystem = scratcDesignSystem;
+  context.registry = registry;
+  context.emotion = emotion;
+  const state = prepareState(app, context);
+  context.state = state;
+  context.pages = preparePages(app, context);
+  context.components = prepareComponents(context);
+  context.utils = prepareUtils(context);
+  if (PACKAGE_MANAGER_TO_CDN[context.packageManager]) {
+    context.dependencies = await prepareDependencies(context);
+  }
+  context.methods = prepareMethods(context);
+  context.routerOptions = initRouter(app, context);
+  context.defaultExtends = [uikit.Box];
+  context.snippets = context.snippets || {};
+  context.functions = context.functions || {};
+  return context;
+};
+const createDomqlElement = async (app, ctx) => {
+  if (!isObject(ctx)) ctx = {};
+  if (isNode(app)) {
+    app = {};
+    ctx.parent = app;
+  } else if (isString(app)) {
+    app = {};
+    ctx.key = app;
+  } else if (!isObject(app)) {
+    app = {};
+  }
+  await prepareContext(app, ctx);
+  app.extends = initializeExtend(app, ctx);
+  app.routes = ctx.pages;
+  app.state = ctx.state;
+  app.context = ctx;
+  app.data = app.data || {};
+  app.data.frameListeners = initAnimationFrame(ctx);
+  await prepareRequire(
+    {
+      functions: ctx.functions,
+      utils: ctx.utils,
+      snippets: ctx.snippets,
+      ...ctx.files
+    },
+    ctx
+  );
+  initializeSync(app, ctx);
+  initializeNotifications(app, ctx);
+  const parentNode = ctx.parent || ctx.document.body;
+  const domqlCreate = DOM.default && DOM.default.create || DOM.create;
+  const smblsApp = await domqlCreate(app, parentNode, ctx.key, {
+    verbose: ctx.verbose,
+    ...ctx.domqlOptions
+  });
+  return smblsApp;
+};
+export {
+  createDomqlElement,
+  prepareContext
+};

package/dist/esm/src/define.js

@@ -0,0 +1,18 @@
+const defaultDefine = {
+  routes: (param) => param,
+  // deps: (param, el) => param || el.parent.deps,
+  $router: async (param, el) => {
+    if (!param) return;
+    const obj = { tag: "fragment", ...param };
+    const set = async () => {
+      await el.set(obj, { preventDefineUpdate: "$router" });
+    };
+    if (el.props && el.props.lazyLoad) {
+      window.requestAnimationFrame(set);
+    } else await set();
+    return obj;
+  }
+};
+export {
+  defaultDefine
+};

package/dist/esm/src/fetchOnCreate.js

@@ -0,0 +1,34 @@
+import { isObject } from "@domql/utils";
+import { fetchProject, fetchProjectAsync } from "@symbo.ls/fetch";
+const fetchSync = async (key, options) => {
+  if (key && options.editor) {
+    try {
+      if (!options.editor.async) await fetchProject(key, options);
+    } catch (e) {
+      console.error(e);
+    }
+  }
+};
+const fetchAsync = (app, key, options, callback) => {
+  if (key && options.editor) {
+    try {
+      if (options.editor.async) {
+        fetchProjectAsync(key, options, callback || ((data) => {
+          const designSystem = data.designSystem;
+          if (isObject(designSystem)) {
+            options.utils.init(designSystem);
+          }
+          if (isObject(data.state)) {
+            app.state.set(data.state);
+          }
+        }));
+      }
+    } catch (e) {
+      console.error(e);
+    }
+  }
+};
+export {
+  fetchAsync,
+  fetchSync
+};