@symbo.ls/create 2.11.507 → 2.11.511

package/dist/cjs/index.js

@@ -51,7 +51,7 @@ const create = (App, options = import_options.default, optionsExternalFile) => {
   const domqlApp = (0, import_createDomql.createDomqlElement)(App, redefinedOptions);
   (0, import_router.popStateRouter)(domqlApp, redefinedOptions);
   if (redefinedOptions.on && redefinedOptions.on.create)
-    redefinedOptions.on.create(domqlApp, redefinedOptions);
+    redefinedOptions.on.create(domqlApp, domqlApp.state, domqlApp.context, redefinedOptions);
   return domqlApp;
 };
 const createAsync = (App, options = import_options.default, optionsExternalFile) => {
@@ -67,7 +67,7 @@ const createSync = async (App, options = import_options.default, optionsExternal
   await (0, import_ferchOnCreate.fetchSync)(key, redefinedOptions);
   const domqlApp = await (0, import_createDomql.createDomqlElement)(App, redefinedOptions);
   if (redefinedOptions.on && redefinedOptions.on.create)
-    await redefinedOptions.on.create(domqlApp, redefinedOptions);
+    await redefinedOptions.on.create(domqlApp, domqlApp.state, domqlApp.context, redefinedOptions);
   return domqlApp;
 };
 const createSkeleton = (App = {}, options = import_options.default, optionsExternalFile) => {

package/dist/esm/createDomql.js

@@ -0,0 +1,93 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+import DOM from "domql";
+import * as uikit from "@symbo.ls/uikit";
+import { isString, isNode, isObject } from "@domql/utils";
+import { defaultDefine } from "./define";
+import { initRouter } from "./router";
+import { initializeExtend, initializeInspect, initializeNotifications, initializeSync } from "./syncExtend";
+import {
+  initAnimationFrame,
+  prepareComponents,
+  prepareDependencies,
+  prepareDesignSystem,
+  prepareWindow,
+  prepareRequire,
+  preparePages,
+  prepareState,
+  prepareUtils,
+  prepareMethods
+} from "./prepare";
+const prepareContext = (app, context = {}) => {
+  const key = context.key = context.key || (isString(app) ? app : "smblsapp");
+  context.define = context.define || defaultDefine;
+  context.window = prepareWindow(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);
+  context.dependencies = prepareDependencies(context);
+  context.methods = prepareMethods(context);
+  context.routerOptions = initRouter(app, context);
+  context.defaultExtends = [uikit.Box];
+  return context;
+};
+const createDomqlElement = async (app, ctx) => {
+  if (!isObject(ctx))
+    ctx = {};
+  if (isNode(app)) {
+    app = {};
+    ctx.parent = app;
+  }
+  if (isString(app)) {
+    app = {};
+    ctx.key = app;
+  }
+  if (!isObject(app)) {
+    app = {};
+  }
+  prepareContext(app, ctx);
+  app.extend = initializeExtend(app, ctx);
+  app.routes = ctx.pages;
+  app.state = ctx.state;
+  app.context = ctx;
+  app.data = app.data || {};
+  app.data.frameListeners = initAnimationFrame();
+  prepareRequire(__spreadValues({
+    functions: ctx.functions,
+    utils: ctx.utils,
+    snippets: ctx.snippets
+  }, ctx.files), ctx);
+  initializeSync(app, ctx);
+  initializeInspect(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, __spreadValues({
+    verbose: ctx.verbose
+  }, ctx.domqlOptions));
+  return smblsApp;
+};
+export {
+  createDomqlElement,
+  prepareContext
+};

package/dist/esm/define.js

@@ -0,0 +1,41 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+import { Collection } from "@symbo.ls/atoms";
+const defaultDefine = {
+  routes: (param) => param,
+  // deps: (param, el) => param || el.parent.deps,
+  $router: (param, el) => {
+    if (!param)
+      return;
+    const obj = __spreadValues({ tag: "fragment" }, param);
+    const set = () => {
+      el.set(obj, { preventDefineUpdate: "$router" });
+    };
+    if (el.props && el.props.lazyLoad) {
+      window.requestAnimationFrame(set);
+    } else
+      set();
+    return obj;
+  },
+  $collection: Collection.define.$collection,
+  $setCollection: Collection.define.$setCollection,
+  $stateCollection: Collection.define.$stateCollection,
+  $propsCollection: Collection.define.$propsCollection
+};
+export {
+  defaultDefine
+};

package/dist/esm/ferchOnCreate.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) => {
+          if (isObject(data.designsystem)) {
+            options.utils.init(data.designsystem);
+          }
+          if (isObject(data.state)) {
+            app.state.set(data.state);
+          }
+        }));
+      }
+    } catch (e) {
+      console.error(e);
+    }
+  }
+};
+export {
+  fetchAsync,
+  fetchSync
+};

package/dist/esm/index.js

@@ -0,0 +1,68 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+import { deepMerge, isObject, isUndefined } from "@domql/utils";
+import * as utils from "./utilImports";
+import { popStateRouter } from "./router";
+import { fetchAsync, fetchSync } from "./ferchOnCreate";
+import DEFAULT_CREATE_OPTIONS from "./options";
+import DYNAMIC_JSON from "@symbo.ls/init/dynamic.json";
+import { createDomqlElement } from "./createDomql";
+const mergeWithLocalFile = (options, optionsExternalFile) => deepMerge(
+  options,
+  isObject(optionsExternalFile) ? optionsExternalFile : DYNAMIC_JSON || {}
+);
+const create = (App, options = DEFAULT_CREATE_OPTIONS, optionsExternalFile) => {
+  const redefinedOptions = __spreadValues(__spreadValues({}, DEFAULT_CREATE_OPTIONS), mergeWithLocalFile(options, optionsExternalFile));
+  const domqlApp = createDomqlElement(App, redefinedOptions);
+  popStateRouter(domqlApp, redefinedOptions);
+  if (redefinedOptions.on && redefinedOptions.on.create)
+    redefinedOptions.on.create(domqlApp, domqlApp.state, domqlApp.context, redefinedOptions);
+  return domqlApp;
+};
+const createAsync = (App, options = DEFAULT_CREATE_OPTIONS, optionsExternalFile) => {
+  const domqlApp = create(App, options, optionsExternalFile);
+  const redefinedOptions = __spreadValues(__spreadValues({}, DEFAULT_CREATE_OPTIONS), mergeWithLocalFile(options, optionsExternalFile));
+  const key = redefinedOptions.key;
+  fetchAsync(domqlApp, key, __spreadValues({ utils }, redefinedOptions));
+  return domqlApp;
+};
+const createSync = async (App, options = DEFAULT_CREATE_OPTIONS, optionsExternalFile) => {
+  const redefinedOptions = __spreadValues(__spreadValues({}, DEFAULT_CREATE_OPTIONS), mergeWithLocalFile(options, optionsExternalFile));
+  const key = options.key;
+  await fetchSync(key, redefinedOptions);
+  const domqlApp = await createDomqlElement(App, redefinedOptions);
+  if (redefinedOptions.on && redefinedOptions.on.create)
+    await redefinedOptions.on.create(domqlApp, domqlApp.state, domqlApp.context, redefinedOptions);
+  return domqlApp;
+};
+const createSkeleton = (App = {}, options = DEFAULT_CREATE_OPTIONS, optionsExternalFile) => {
+  return create(
+    __spreadValues({
+      deps: { isUndefined }
+    }, App),
+    deepMerge({ domqlOptions: { onlyResolveExtends: true } }, options),
+    optionsExternalFile
+  );
+};
+var src_default = create;
+export {
+  create,
+  createAsync,
+  createSkeleton,
+  createSync,
+  src_default as default
+};

package/dist/esm/initEmotion.js

@@ -0,0 +1,42 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+import { transformDOMQLEmotion } from "@domql/emotion";
+import { emotion as defaultEmotion } from "@symbo.ls/emotion";
+import { init } from "@symbo.ls/init";
+import { deepClone, deepMerge } from "@domql/utils";
+import { DESIGN_SYSTEM_OPTIONS } from "./options";
+import { DEFAULT_CONFIG } from "@symbo.ls/default-config";
+const initEmotion = (key, options = {}) => {
+  var _a;
+  const doc = options.parent || options.document || document;
+  const initOptions = options.initOptions || {};
+  const emotion = initOptions.emotion;
+  if (!initOptions.emotion)
+    initOptions.emotion = defaultEmotion;
+  const registry = options.registry || transformDOMQLEmotion(initOptions.emotion, options);
+  const designSystem = initOptions.useDefaultConfig || ((_a = options.designSystem) == null ? void 0 : _a.useDefaultConfig) ? deepMerge(options.designSystem, deepClone(DEFAULT_CONFIG)) : options.designSystem || deepClone(DEFAULT_CONFIG);
+  const scratchSystem = init(designSystem, __spreadValues(__spreadValues({
+    key,
+    emotion,
+    verbose: options.verbose,
+    document: doc
+  }, DESIGN_SYSTEM_OPTIONS), initOptions));
+  return [scratchSystem, emotion, registry];
+};
+export {
+  initEmotion
+};

package/dist/esm/options.js

@@ -0,0 +1,28 @@
+import { defaultDefine } from "./define";
+const DESIGN_SYSTEM_OPTIONS = {
+  useReset: true,
+  useVariable: true,
+  useIconSprite: true,
+  useSvgSprite: true,
+  useDocumentTheme: true,
+  useDefaultIcons: true,
+  useFontImport: true,
+  useDefaultConfig: true
+};
+const CREATE_OPTIONS = {
+  state: {},
+  pages: {},
+  components: {},
+  router: {
+    initRouter: true,
+    popState: true,
+    injectRouterInLinkComponent: true
+  },
+  define: defaultDefine
+};
+var options_default = CREATE_OPTIONS;
+export {
+  CREATE_OPTIONS,
+  DESIGN_SYSTEM_OPTIONS,
+  options_default as default
+};

package/dist/esm/prepare.js

@@ -0,0 +1,203 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+import {
+  isObject,
+  deepMerge,
+  deepClone,
+  merge,
+  checkIfKeyIsComponent
+} from "@domql/utils";
+import { initEmotion } from "./initEmotion";
+import * as uikit from "@symbo.ls/uikit";
+import * as utils from "./utilImports";
+import * as routerUtils from "@domql/router";
+const ENV = "development";
+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;
+  return context.window = context.window || window;
+};
+function onlyDotsAndNumbers(str) {
+  return /^[0-9.]+$/.test(str) && str !== "";
+}
+const UIkitWithPrefix = () => {
+  const newObj = {};
+  for (const key in uikit) {
+    if (Object.prototype.hasOwnProperty.call(uikit, key)) {
+      if (checkIfKeyIsComponent(key)) {
+        newObj[`smbls.${key}`] = uikit[key];
+      } else {
+        newObj[key] = uikit[key];
+      }
+    }
+  }
+  return newObj;
+};
+const prepareComponents = (context) => {
+  return context.components ? __spreadValues(__spreadValues({}, UIkitWithPrefix()), context.components) : UIkitWithPrefix();
+};
+const prepareUtils = (context) => {
+  return __spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues({}, utils), routerUtils), utils.scratchUtils), context.utils), context.snippets), context.functions);
+};
+const prepareMethods = (context) => {
+  return __spreadProps(__spreadValues({}, context.methods || {}), {
+    require: context.utils.require,
+    requireOnDemand: context.utils.requireOnDemand,
+    call: function(fnKey, ...args) {
+      var _a;
+      return (_a = context.utils[fnKey] || context.functions[fnKey] || context.methods[fnKey] || context.snippets[fnKey]) == null ? void 0 : _a.call(this, ...args);
+    }
+  });
+};
+const cachedDeps = {};
+const prepareDependencies = ({
+  dependencies,
+  dependenciesOnDemand,
+  document: document2
+}) => {
+  if (!dependencies || Object.keys(dependencies).length === 0) {
+    return null;
+  }
+  for (const [dependency, version] of Object.entries(dependencies)) {
+    if (version === "loading" || version === "error") {
+      continue;
+    }
+    const random = ENV === "development" ? `?${Math.random()}` : "";
+    let url = `https://pkg.symbo.ls/${dependency}/${version}.js${random}`;
+    if (dependency.split("/").length > 2 || !onlyDotsAndNumbers(version)) {
+      url = `https://pkg.symbo.ls/${dependency}${random}`;
+    }
+    if (dependenciesOnDemand && dependenciesOnDemand[dependency])
+      continue;
+    try {
+      if (cachedDeps[dependency])
+        return;
+      cachedDeps[dependency] = true;
+      utils.loadJavascriptFileEmbedSync(url, document2);
+    } catch (e) {
+      console.error(`Failed to load ${dependency}:`, e);
+    }
+  }
+  return dependencies;
+};
+const prepareRequire = (packages, ctx) => {
+  const windowOpts = ctx.window || window;
+  const initRequire = (ctx2) => (key) => {
+    const windowOpts2 = ctx2.window || window;
+    const pkg = windowOpts2.packages[key];
+    if (typeof pkg === "function")
+      return pkg();
+    return pkg;
+  };
+  const initRequireOnDemand = (ctx2) => (key) => {
+    const { dependenciesOnDemand } = ctx2;
+    const documentOpts = ctx2.document || document;
+    const windowOpts2 = ctx2.window || window;
+    if (!windowOpts2.packages[key]) {
+      const random = ENV === "development" ? `?${Math.random()}` : "";
+      if (dependenciesOnDemand && dependenciesOnDemand[key]) {
+        const version = dependenciesOnDemand[key];
+        const url = `https://pkg.symbo.ls/${key}/${version}.js${random}`;
+        ctx2.utils.loadJavascriptFileEmbedSync(url, documentOpts);
+      } else {
+        const url = `https://pkg.symbo.ls/${key}${random}`;
+        ctx2.utils.loadJavascriptFileEmbedSync(url, documentOpts, (d) => {
+          windowOpts2.packages[key] = "loadedOnDeman";
+        });
+      }
+    }
+    return windowOpts2.require(key);
+  };
+  if (windowOpts.packages) {
+    windowOpts.packages = merge(windowOpts.packages, packages);
+  } else {
+    windowOpts.packages = packages;
+  }
+  if (!windowOpts.require) {
+    ctx.utils.require = initRequire(ctx);
+    windowOpts.require = ctx.utils.require;
+  }
+  if (!windowOpts.requireOnDemand) {
+    ctx.utils.requireOnDemand = initRequireOnDemand(ctx);
+    windowOpts.requireOnDemand = ctx.utils.requireOnDemand;
+  }
+};
+const prepareDesignSystem = (key, context) => {
+  const [scratcDesignhSystem, emotion, registry] = 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)
+    deepMerge(state, app.state);
+  return deepClone(state);
+};
+const preparePages = (app, context) => {
+  if (isObject(app.routes) && isObject(context.pages)) {
+    merge(app.routes, context.pages);
+  }
+  const pages = app.routes || context.pages || {};
+  return Object.keys(pages).filter((v) => !v.startsWith("/")).reduce((pages2, v) => {
+    const index = v === "index" ? "" : v;
+    pages2["/" + index] = pages2[v];
+    delete pages2[v];
+    return pages2;
+  }, pages);
+};
+const initAnimationFrame = () => {
+  const frameListeners = /* @__PURE__ */ new Set();
+  function requestFrame() {
+    for (const element of frameListeners) {
+      if (!document.body.contains(element.node)) {
+        frameListeners.delete(element);
+      } else {
+        try {
+          (element.on.frame || element.props.onFrame)(element, element.state, element.context);
+        } catch (e) {
+          console.warn(e);
+        }
+      }
+    }
+    window.requestAnimationFrame(requestFrame);
+  }
+  requestFrame();
+  return frameListeners;
+};
+export {
+  UIkitWithPrefix,
+  initAnimationFrame,
+  prepareComponents,
+  prepareDependencies,
+  prepareDesignSystem,
+  prepareMethods,
+  preparePages,
+  prepareRequire,
+  prepareState,
+  prepareUtils,
+  prepareWindow
+};

package/dist/esm/router.js

@@ -0,0 +1,61 @@
+import { router as defaultRouter } from "@domql/router";
+import { window, deepMerge, merge, isUndefined } from "@domql/utils";
+import { Link, RouterLink } from "@symbo.ls/uikit";
+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
+    merge(context.router || {}, DEFAULT_ROUTING_OPTIONS);
+  const routerOptions = context.router;
+  const router = context.utils && context.utils.router ? context.utils.router : defaultRouter;
+  const onRouterRenderDefault = (el, s) => {
+    const { pathname, search, hash } = window.location;
+    const url = pathname + search + hash;
+    if (el.routes)
+      router(url, el, {}, { initialRender: true });
+  };
+  const hasRenderRouter = element.on && !isUndefined(element.on.renderRouter);
+  if (routerOptions && routerOptions.initRouter && !hasRenderRouter) {
+    if (element.on) {
+      element.on.renderRouter = onRouterRenderDefault;
+    } else {
+      element.on = {
+        renderRouter: onRouterRenderDefault
+      };
+    }
+  }
+  injectRouterInLinkComponent(routerOptions);
+  return routerOptions;
+};
+let popStateFired;
+const popStateRouter = (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 : defaultRouter;
+  window.onpopstate = (e) => {
+    const { pathname, search, hash } = window.location;
+    const url = pathname + search + hash;
+    router(url, element, {}, { pushState: false, scrollToTop: false, level: 0 });
+  };
+};
+const injectRouterInLinkComponent = (routerOptions) => {
+  if (routerOptions && routerOptions.injectRouterInLinkComponent) {
+    return deepMerge(Link, RouterLink);
+  }
+};
+export {
+  initRouter,
+  injectRouterInLinkComponent,
+  popStateRouter
+};

package/dist/esm/syncExtend.js

@@ -0,0 +1,56 @@
+import { isObjectLike, isUndefined, isDevelopment, isArray } from "@domql/utils";
+import { SyncComponent, Inspect, Notifications } from "@symbo.ls/sync";
+const initializeExtend = (app, ctx) => {
+  return isObjectLike(app.extend) ? app.extend : [];
+};
+const initializeSync = (app, ctx) => {
+  const { editor } = ctx;
+  if (!editor)
+    return;
+  const liveSync = isUndefined(editor.liveSync) ? isDevelopment() : editor.liveSync;
+  if (liveSync) {
+    if (isArray(app.extend))
+      app.extend.push(SyncComponent);
+    else if (app.extend) {
+      app.extend = [app.extend, SyncComponent];
+    } else {
+      app.extend = [SyncComponent];
+    }
+  }
+};
+const initializeInspect = (app, ctx) => {
+  const { editor } = ctx;
+  if (!editor)
+    return;
+  const inspect = isUndefined(editor.inspect) ? isDevelopment() : editor.inspect;
+  if (inspect) {
+    if (isArray(app.extend))
+      app.extend.push(Inspect);
+    else if (app.extend) {
+      app.extend = [app.extend, Inspect];
+    } else {
+      app.extend = [Inspect];
+    }
+  }
+};
+const initializeNotifications = (app, ctx) => {
+  const { editor } = ctx;
+  if (!editor)
+    return;
+  const verbose = isUndefined(editor.verbose) ? isDevelopment() || ctx.verbose : editor.verbose;
+  if (verbose) {
+    if (isArray(app.extend))
+      app.extend.push(Notifications);
+    else if (app.extend) {
+      app.extend = [app.extend, Notifications];
+    } else {
+      app.extend = [Notifications];
+    }
+  }
+};
+export {
+  initializeExtend,
+  initializeInspect,
+  initializeNotifications,
+  initializeSync
+};

package/dist/esm/utilImports.js

@@ -0,0 +1,14 @@
+import { scratchUtils, scratchSystem, set } from "@symbo.ls/scratch";
+export * from "@domql/utils";
+export * from "@symbo.ls/utils";
+import { init, reinit, applyCSS } from "@symbo.ls/init";
+export * from "@domql/report";
+export * from "@domql/router";
+export {
+  applyCSS,
+  init,
+  reinit,
+  scratchSystem,
+  scratchUtils,
+  set
+};