smbls 3.2.3 → 3.2.8

package/bin/smbls.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '@symbo.ls/cli/bin/index.js'

package/dist/cjs/index.js

@@ -17,11 +17,10 @@ var index_exports = {};
 module.exports = __toCommonJS(index_exports);
 __reExport(index_exports, require("@domql/utils"), module.exports);
 __reExport(index_exports, require("attrs-in-props"), module.exports);
-__reExport(index_exports, require("@symbo.ls/create"), module.exports);
 __reExport(index_exports, require("css-in-props"), module.exports);
 __reExport(index_exports, require("@symbo.ls/default-config"), module.exports);
 __reExport(index_exports, require("@symbo.ls/emotion"), module.exports);
-__reExport(index_exports, require("@symbo.ls/init"), module.exports);
 __reExport(index_exports, require("@symbo.ls/scratch"), module.exports);
 __reExport(index_exports, require("@symbo.ls/uikit"), module.exports);
-__reExport(index_exports, require("@symbo.ls/utils"), module.exports);
+__reExport(index_exports, require("@symbo.ls/smbls-utils"), module.exports);
+__reExport(index_exports, require("./src/index.js"), module.exports);

package/dist/cjs/src/createDomql.js

@@ -0,0 +1,110 @@
+"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 createDomql_exports = {};
+__export(createDomql_exports, {
+  createDomqlElement: () => createDomqlElement,
+  prepareContext: () => prepareContext
+});
+module.exports = __toCommonJS(createDomql_exports);
+var import_domql = __toESM(require("domql"), 1);
+var uikit = __toESM(require("@symbo.ls/uikit"), 1);
+var import_css_in_props = require("css-in-props");
+var import_utils = require("@domql/utils");
+var import_element = require("@domql/element");
+var import_define = require("./define.js");
+var import_router = require("./router.js");
+var import_syncExtend = require("./syncExtend.js");
+var import_prepare = require("./prepare.js");
+const prepareContext = async (app, context = {}) => {
+  const key = context.key = context.key || ((0, import_utils.isString)(app) ? app : "smblsapp");
+  context.define = context.define || import_define.defaultDefine;
+  context.cssPropsRegistry = import_css_in_props.CSS_PROPS_REGISTRY;
+  context.window = (0, import_prepare.prepareWindow)(context);
+  if (context.sharedLibraries && context.sharedLibraries.length) {
+    (0, import_prepare.prepareSharedLibs)(context);
+  }
+  const [scratcDesignSystem, emotion, registry] = (0, import_prepare.prepareDesignSystem)(
+    key,
+    context
+  );
+  context.designSystem = scratcDesignSystem;
+  context.registry = registry;
+  context.emotion = emotion;
+  const state = (0, import_prepare.prepareState)(app, context);
+  context.state = state;
+  context.pages = (0, import_prepare.preparePages)(app, context);
+  context.components = (0, import_prepare.prepareComponents)(context);
+  context.utils = (0, import_prepare.prepareUtils)(context);
+  if (import_prepare.PACKAGE_MANAGER_TO_CDN[context.packageManager]) {
+    context.dependencies = await (0, import_prepare.prepareDependencies)(context);
+  }
+  context.methods = (0, import_prepare.prepareMethods)(context);
+  context.routerOptions = (0, import_router.initRouter)(app, context);
+  context.defaultExtends = [uikit.Box];
+  context.snippets = context.snippets || {};
+  context.functions = context.functions || {};
+  return context;
+};
+const createDomqlElement = async (app, ctx) => {
+  if (!(0, import_utils.isObject)(ctx)) ctx = {};
+  if ((0, import_utils.isNode)(app)) {
+    app = {};
+    ctx.parent = app;
+  } else if ((0, import_utils.isString)(app)) {
+    app = {};
+    ctx.key = app;
+  } else if (!(0, import_utils.isObject)(app)) {
+    app = {};
+  }
+  await prepareContext(app, ctx);
+  app.extends = (0, import_syncExtend.initializeExtend)(app, ctx);
+  app.routes = ctx.pages;
+  app.state = ctx.state;
+  app.context = ctx;
+  app.data = app.data || {};
+  app.data.frameListeners = (0, import_element.initAnimationFrame)(ctx);
+  await (0, import_prepare.prepareRequire)(
+    {
+      functions: ctx.functions,
+      utils: ctx.utils,
+      snippets: ctx.snippets,
+      ...ctx.files
+    },
+    ctx
+  );
+  (0, import_syncExtend.initializeSync)(app, ctx);
+  (0, import_syncExtend.initializeNotifications)(app, ctx);
+  const parentNode = ctx.parent || ctx.document.body;
+  const domqlCreate = import_domql.default.default && import_domql.default.default.create || import_domql.default.create;
+  const smblsApp = await domqlCreate(app, parentNode, ctx.key, {
+    verbose: ctx.verbose,
+    ...ctx.domqlOptions
+  });
+  return smblsApp;
+};

package/dist/cjs/src/define.js

@@ -0,0 +1,38 @@
+"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 define_exports = {};
+__export(define_exports, {
+  defaultDefine: () => defaultDefine
+});
+module.exports = __toCommonJS(define_exports);
+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;
+  }
+};

package/dist/cjs/src/fetchOnCreate.js

@@ -0,0 +1,54 @@
+"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 fetchOnCreate_exports = {};
+__export(fetchOnCreate_exports, {
+  fetchAsync: () => fetchAsync,
+  fetchSync: () => fetchSync
+});
+module.exports = __toCommonJS(fetchOnCreate_exports);
+var import_utils = require("@domql/utils");
+var import_fetch = require("@symbo.ls/fetch");
+const fetchSync = async (key, options) => {
+  if (key && options.editor) {
+    try {
+      if (!options.editor.async) await (0, import_fetch.fetchProject)(key, options);
+    } catch (e) {
+      console.error(e);
+    }
+  }
+};
+const fetchAsync = (app, key, options, callback) => {
+  if (key && options.editor) {
+    try {
+      if (options.editor.async) {
+        (0, import_fetch.fetchProjectAsync)(key, options, callback || ((data) => {
+          const designSystem = data.designSystem;
+          if ((0, import_utils.isObject)(designSystem)) {
+            options.utils.init(designSystem);
+          }
+          if ((0, import_utils.isObject)(data.state)) {
+            app.state.set(data.state);
+          }
+        }));
+      }
+    } catch (e) {
+      console.error(e);
+    }
+  }
+};

package/dist/cjs/src/index.js

@@ -0,0 +1,109 @@
+"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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+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 src_exports = {};
+__export(src_exports, {
+  DEFAULT_CONTEXT: () => import_options2.DEFAULT_CONTEXT,
+  DESIGN_SYSTEM_OPTIONS: () => import_options2.DESIGN_SYSTEM_OPTIONS,
+  ROUTER_OPTIONS: () => import_options2.ROUTER_OPTIONS,
+  create: () => create,
+  createAsync: () => createAsync,
+  createSkeleton: () => createSkeleton,
+  createSync: () => createSync,
+  default: () => src_default
+});
+module.exports = __toCommonJS(src_exports);
+var import_utils = require("@domql/utils");
+var utils = __toESM(require("./utilImports.js"), 1);
+var import_router = require("./router.js");
+var import_fetchOnCreate = require("./fetchOnCreate.js");
+var import_options = __toESM(require("./options.js"), 1);
+var import_dynamic = __toESM(require("../dynamic.json"), 1);
+var import_createDomql = require("./createDomql.js");
+__reExport(src_exports, require("./init.js"), module.exports);
+var import_options2 = require("./options.js");
+const mergeWithLocalFile = (options, optionsExternalFile) => (0, import_utils.deepMerge)(
+  options,
+  (0, import_utils.isObject)(optionsExternalFile) ? optionsExternalFile : import_dynamic.default || {}
+);
+const create = (App, options = import_options.default, optionsExternalFile) => {
+  const redefinedOptions = {
+    ...import_options.default,
+    ...mergeWithLocalFile(options, optionsExternalFile)
+  };
+  const domqlApp = (0, import_createDomql.createDomqlElement)(App, redefinedOptions).then((App2) => {
+    (0, import_router.onpopstateRouter)(App2, redefinedOptions);
+    if (redefinedOptions.on && redefinedOptions.on.create)
+      redefinedOptions.on.create(
+        domqlApp,
+        domqlApp.state,
+        domqlApp.context,
+        redefinedOptions
+      );
+  });
+  return domqlApp;
+};
+const createAsync = (App, options = import_options.default, optionsExternalFile) => {
+  const domqlApp = create(App, options, optionsExternalFile);
+  const redefinedOptions = {
+    ...import_options.default,
+    ...mergeWithLocalFile(options, optionsExternalFile)
+  };
+  const key = redefinedOptions.key;
+  (0, import_fetchOnCreate.fetchAsync)(domqlApp, key, { utils, ...redefinedOptions });
+  return domqlApp;
+};
+const createSync = async (App, options = import_options.default, optionsExternalFile) => {
+  const redefinedOptions = {
+    ...import_options.default,
+    ...mergeWithLocalFile(options, optionsExternalFile)
+  };
+  const key = options.key;
+  await (0, import_fetchOnCreate.fetchSync)(key, redefinedOptions);
+  const domqlApp = await (0, import_createDomql.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 = import_options.default, optionsExternalFile) => {
+  return create(
+    {
+      deps: { isUndefined: import_utils.isUndefined },
+      ...App
+    },
+    (0, import_utils.deepMerge)({ domqlOptions: { onlyResolveExtends: true } }, options),
+    optionsExternalFile
+  );
+};
+var src_default = create;

package/dist/cjs/src/init.js

@@ -0,0 +1,127 @@
+"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 init_exports = {};
+__export(init_exports, {
+  DYNAMIC_JSON: () => import_dynamic.default,
+  applyCSS: () => applyCSS,
+  init: () => init,
+  reinit: () => reinit,
+  setClass: () => setClass,
+  updateVars: () => updateVars
+});
+module.exports = __toCommonJS(init_exports);
+var import_scratch = require("@symbo.ls/scratch");
+var import_utils = require("@domql/utils");
+var import_emotion = require("@symbo.ls/emotion");
+var import_dynamic = __toESM(require("../dynamic.json"), 1);
+const CONFIG = (0, import_scratch.getActiveConfig)();
+const mergeWithLocalFile = (config = CONFIG, options) => {
+  const rcfile = (0, import_utils.isObject)(options.localFile) ? options.localFile : import_dynamic.default || {};
+  const clonedFile = (0, import_utils.deepClone)(rcfile.designSystem || {});
+  return (0, import_utils.deepMerge)(config, clonedFile);
+};
+const SET_OPTIONS = {
+  emotion: import_emotion.emotion,
+  useVariable: true,
+  useReset: true,
+  useFontImport: true,
+  useIconSprite: true,
+  useDocumentTheme: true,
+  useSvgSprite: true
+};
+const init = (config, options = SET_OPTIONS) => {
+  const emotion = options.emotion || import_emotion.emotion;
+  const resultConfig = mergeWithLocalFile(config || {}, options);
+  const conf = (0, import_scratch.set)(
+    {
+      verbose: options.verbose,
+      useReset: options.useReset,
+      useFontImport: options.useFontImport,
+      useVariable: options.useVariable,
+      useSvgSprite: options.useSvgSprite,
+      useDocumentTheme: options.useDocumentTheme,
+      useIconSprite: options.useIconSprite,
+      useDefaultConfig: options.useDefaultConfig,
+      globalTheme: options.globalTheme,
+      ...resultConfig
+    },
+    { newConfig: options.newConfig }
+  );
+  const FontFace = (0, import_scratch.getFontFaceString)(conf.FONT);
+  const useReset = conf.useReset;
+  const useVariable = conf.useVariable;
+  const useFontImport = conf.useFontImport;
+  const useSvgSprite = conf.useSvgSprite;
+  const hasSvgs = config.svg || config.SVG;
+  const useIconSprite = conf.useIconSprite;
+  const hasIcons = config.icons || config.ICONS;
+  if (useFontImport) emotion.injectGlobal(FontFace);
+  if (useVariable) emotion.injectGlobal({ ":root": conf.CSS_VARS });
+  if (useReset) emotion.injectGlobal(conf.RESET);
+  if (conf.ANIMATION) {
+    const keyframesCSS = {};
+    for (const name in conf.ANIMATION) {
+      keyframesCSS[`@keyframes ${name}`] = conf.ANIMATION[name];
+    }
+    emotion.injectGlobal(keyframesCSS);
+  }
+  if (hasSvgs) (0, import_scratch.appendSVGSprite)(hasSvgs, { document: options.document });
+  else if (useSvgSprite)
+    (0, import_scratch.appendSVGSprite)(conf.SVG, { document: options.document });
+  if (hasIcons) (0, import_scratch.appendSvgIconsSprite)(hasIcons, { document: options.document });
+  else if (useIconSprite)
+    (0, import_scratch.appendSvgIconsSprite)(conf.ICONS, { document: options.document });
+  return conf;
+};
+const UPDATE_OPTIONS = {
+  emotion: import_emotion.emotion
+};
+const reinit = (config, options = UPDATE_OPTIONS) => {
+  const emotion = options.emotion || import_emotion.emotion;
+  const resultConfig = mergeWithLocalFile(config || {}, options);
+  const conf = (0, import_scratch.set)({
+    verbose: false,
+    ...resultConfig
+  });
+  if (!options.preventInject) {
+    emotion.injectGlobal({ ":root": conf.CSS_VARS });
+    emotion.injectGlobal(conf.RESET);
+  }
+  return conf;
+};
+const applyCSS = (styles, options = UPDATE_OPTIONS) => {
+  const emotion = options.emotion || import_emotion.emotion;
+  emotion.injectGlobal(styles);
+};
+const updateVars = (config, options = UPDATE_OPTIONS) => {
+  const emotion = options.emotion || import_emotion.emotion;
+  emotion.injectGlobal({ ":root": config.CSS_VARS });
+};
+const setClass = (props, options = UPDATE_OPTIONS) => {
+};

package/dist/cjs/src/options.js

@@ -0,0 +1,57 @@
+"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 options_exports = {};
+__export(options_exports, {
+  CREATE_OPTIONS: () => CREATE_OPTIONS,
+  DEFAULT_CONTEXT: () => DEFAULT_CONTEXT,
+  DESIGN_SYSTEM_OPTIONS: () => DESIGN_SYSTEM_OPTIONS,
+  ROUTER_OPTIONS: () => ROUTER_OPTIONS,
+  default: () => options_default
+});
+module.exports = __toCommonJS(options_exports);
+var import_define = require("./define.js");
+var import_package = require("../package.json");
+const DESIGN_SYSTEM_OPTIONS = {
+  useReset: true,
+  useVariable: true,
+  useIconSprite: true,
+  useSvgSprite: true,
+  useDocumentTheme: true,
+  useDefaultIcons: true,
+  useFontImport: true,
+  useDefaultConfig: true
+};
+const ROUTER_OPTIONS = {
+  initRouter: true,
+  popState: true,
+  injectRouterInLinkComponent: true
+};
+const DEFAULT_CONTEXT = {
+  ...DESIGN_SYSTEM_OPTIONS,
+  router: ROUTER_OPTIONS,
+  version: import_package.version
+};
+const CREATE_OPTIONS = {
+  state: {},
+  pages: {},
+  components: {},
+  router: ROUTER_OPTIONS,
+  define: import_define.defaultDefine
+};
+var options_default = CREATE_OPTIONS;