@symbo.ls/create 2.11.39 → 2.11.98

package/dist/cjs/define.js

@@ -0,0 +1,43 @@
+"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);
+var import_uikit = require("@symbo.ls/uikit");
+const defaultDefine = {
+  routes: (param) => param,
+  $router: (param, el) => {
+    if (!param)
+      return;
+    const obj = { tag: "fragment", ...param };
+    const set = () => {
+      el.set(obj, { preventDefineUpdate: "$router" });
+    };
+    if (el.props && el.props.lazyLoad) {
+      window.requestAnimationFrame(set);
+    } else
+      set();
+    return obj;
+  },
+  $setCollection: import_uikit.Collection.define.$setCollection,
+  $setStateCollection: import_uikit.Collection.define.$setStateCollection,
+  $setPropsCollection: import_uikit.Collection.define.$setPropsCollection
+};

package/dist/cjs/ferchOnCreate.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 ferchOnCreate_exports = {};
+__export(ferchOnCreate_exports, {
+  fetchAsync: () => fetchAsync,
+  fetchSync: () => fetchSync
+});
+module.exports = __toCommonJS(ferchOnCreate_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 {
+      const defaultCallback = (data) => {
+        if ((0, import_utils.isObject)(data.designsystem)) {
+          options.utils.init(data.designsystem);
+        }
+        if ((0, import_utils.isObject)(data.state)) {
+          app.state.set(data.state);
+        }
+      };
+      if (options.editor.async)
+        (0, import_fetch.fetchProjectAsync)(key, options, callback || defaultCallback);
+    } catch (e) {
+      console.error(e);
+    }
+  }
+};

package/dist/cjs/index.js

@@ -0,0 +1,138 @@
+"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 src_exports = {};
+__export(src_exports, {
+  create: () => create,
+  createSync: () => createSync,
+  default: () => src_default
+});
+module.exports = __toCommonJS(src_exports);
+var import_domql = __toESM(require("domql"), 1);
+var import_utils = require("@domql/utils");
+var utils = __toESM(require("./utilImports"), 1);
+var uikit = __toESM(require("@symbo.ls/uikit"), 1);
+var import_define = require("./define");
+var import_router = require("./router");
+var import_ferchOnCreate = require("./ferchOnCreate");
+var import_initEmotion = require("./initEmotion");
+var import_syncExtend = require("./syncExtend");
+var import_options = __toESM(require("./options"), 1);
+var import_dynamic = __toESM(require("@symbo.ls/init/dynamic.json"), 1);
+const SYMBOLS_KEY = process.env.SYMBOLS_KEY;
+const mergeWithLocalFile = (options, optionsExternalFile) => {
+  const rcfile = (0, import_utils.isObject)(optionsExternalFile) ? optionsExternalFile : import_dynamic.default || {};
+  return (0, import_utils.deepMerge)(options, rcfile);
+};
+const create = async (App, options = import_options.default, optionsExternalFile) => {
+  const appIsKey = (0, import_utils.isString)(App);
+  options = mergeWithLocalFile(options, optionsExternalFile);
+  const key = options.key || SYMBOLS_KEY || (appIsKey ? App : "");
+  if (appIsKey)
+    App = {};
+  await (0, import_ferchOnCreate.fetchSync)(key, options);
+  const doc = options.parent || options.document || document;
+  const [scratchSystem, emotion, registry] = (0, import_initEmotion.initEmotion)(key, options);
+  const state = options.state || {};
+  const pages = options.pages || {};
+  const components = options.components ? { ...uikit, ...options.components } : uikit;
+  const designSystem = scratchSystem || {};
+  const snippets = { ...utils, ...utils.scratchUtils, ...options.snippets || {} };
+  const define = options.define || import_define.defaultDefine;
+  const routerOptions = (0, import_router.initRouter)(App, options);
+  const extend = (0, import_syncExtend.applySyncDebug)([App], options);
+  const domqlApp = import_domql.default.create({
+    extend,
+    routes: options.pages,
+    state,
+    context: {
+      key,
+      components,
+      state,
+      pages,
+      designSystem,
+      snippets,
+      utils: snippets,
+      define,
+      registry,
+      emotion,
+      routerOptions,
+      document: doc
+    }
+  }, doc.body, key, {
+    extend: [uikit.Box],
+    verbose: options.verbose,
+    ...options.domqlOptions
+  });
+  (0, import_syncExtend.applyInspectListener)(domqlApp, options);
+  (0, import_router.popStateRouter)(domqlApp, options);
+  if (options.on && options.on.create)
+    options.on.create(domqlApp, options);
+  (0, import_ferchOnCreate.fetchAsync)(domqlApp, key, {
+    utils,
+    ...options
+  });
+  return domqlApp;
+};
+const createSync = (App, options = import_options.default, optionsExternalFile) => {
+  const appIsKey = (0, import_utils.isString)(App);
+  options = mergeWithLocalFile(options, optionsExternalFile);
+  const key = options.key || SYMBOLS_KEY || (appIsKey ? App : "");
+  if (appIsKey)
+    App = {};
+  const doc = options.parent || options.document || document;
+  const [scratchSystem, emotion, registry] = (0, import_initEmotion.initEmotion)(key, options);
+  const state = options.state || {};
+  const components = options.components ? { ...uikit, ...options.components } : uikit;
+  const designSystem = scratchSystem || {};
+  const snippets = { ...utils, ...options.snippets || {} };
+  const define = options.define || import_define.defaultDefine;
+  const extend = (0, import_syncExtend.applySyncDebug)([App], options);
+  const domqlApp = import_domql.default.create({
+    extend,
+    state,
+    context: {
+      key,
+      components,
+      state,
+      designSystem,
+      snippets,
+      utils: snippets,
+      define,
+      registry,
+      emotion,
+      document: doc
+    }
+  }, doc.body, key, {
+    // extend: [uikit.Box],
+    verbose: options.verbose,
+    ...options.domqlOptions
+  });
+  return domqlApp;
+};
+var src_default = create;

package/dist/cjs/initEmotion.js

@@ -0,0 +1,54 @@
+"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 initEmotion_exports = {};
+__export(initEmotion_exports, {
+  initEmotion: () => initEmotion
+});
+module.exports = __toCommonJS(initEmotion_exports);
+var import_emotion = require("@domql/emotion");
+var import_emotion2 = require("@symbo.ls/emotion");
+var import_init = require("@symbo.ls/init");
+var import_options = __toESM(require("./options"), 1);
+const initEmotion = (key, options = import_options.default) => {
+  const doc = options.parent || options.document || document;
+  const initOptions = options.initOptions || {};
+  const emotion = initOptions.emotion || import_emotion2.emotion;
+  if (!initOptions.emotion)
+    initOptions.emotion = emotion;
+  const registry = options.registry || (0, import_emotion.transformDOMQLEmotion)(initOptions.emotion, options);
+  const scratchSystem = (0, import_init.init)(options.designSystem || {}, {
+    key,
+    emotion,
+    verbose: options.verbose,
+    document: doc,
+    ...import_options.default.designSystem,
+    ...initOptions
+  });
+  return [scratchSystem, emotion, registry];
+};

package/dist/cjs/options.js

@@ -0,0 +1,47 @@
+"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, {
+  default: () => options_default
+});
+module.exports = __toCommonJS(options_exports);
+var import_define = require("./define");
+var import_emotion = require("@symbo.ls/emotion");
+var options_default = {
+  editor: {},
+  state: {},
+  pages: {},
+  designSystem: {
+    useReset: true,
+    useVariable: true,
+    useIconSprite: true,
+    useSvgSprite: true,
+    useDocumentTheme: true,
+    useFontImport: true
+  },
+  components: {},
+  initOptions: {
+    emotion: import_emotion.emotion
+  },
+  router: {
+    initRouter: true,
+    injectRouterInLinkComponent: true
+  },
+  define: import_define.defaultDefine
+};

package/dist/cjs/package.json

@@ -0,0 +1,4 @@
+{
+  "type": "commonjs",
+  "main": "index.js"
+}

package/dist/cjs/router.js

@@ -0,0 +1,78 @@
+"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,
+  popStateRouter: () => popStateRouter
+});
+module.exports = __toCommonJS(router_exports);
+var import_router = require("@domql/router");
+var import_globals = require("@domql/globals");
+var import_uikit = require("@symbo.ls/uikit");
+var import_utils = require("@domql/utils");
+const DEFAULT_ROUTING_OPTIONS = {
+  initRouter: true,
+  injectRouterInLinkComponent: true,
+  popState: true
+};
+const initRouter = (element, options) => {
+  let routerOptions = (0, import_utils.merge)(options.routerOptions || {}, DEFAULT_ROUTING_OPTIONS);
+  if (routerOptions === false)
+    return;
+  if (routerOptions === true)
+    routerOptions = DEFAULT_ROUTING_OPTIONS;
+  const router = options.snippets && options.snippets.router ? options.snippets.router : import_router.router;
+  const onRouterRenderDefault = (el, s) => {
+    const { pathname, hash } = import_globals.window.location;
+    const url = pathname + hash;
+    if (el.routes)
+      router(url, el, {}, { initialRender: true });
+  };
+  const hasRenderRouter = element.on && !(0, import_utils.isUndefined)(element.on.renderRouter);
+  if (routerOptions.initRouter && !hasRenderRouter) {
+    if (element.on) {
+      element.on.renderRouter = onRouterRenderDefault;
+    } else {
+      element.on = {
+        renderRouter: onRouterRenderDefault
+      };
+    }
+  }
+  injectRouterInLinkComponent(routerOptions);
+  return routerOptions;
+};
+let popStateFired;
+const popStateRouter = (element, options) => {
+  if (popStateFired)
+    return;
+  const routerOptions = options.routerOptions || DEFAULT_ROUTING_OPTIONS;
+  if (!routerOptions.popState)
+    return;
+  const router = options.snippets && options.snippets.router ? options.snippets.router : import_router.router;
+  const { pathname, hash } = import_globals.window.location;
+  const url = pathname + hash;
+  import_globals.window.onpopstate = (e) => router(url, element, { pushState: false, level: 0 });
+  popStateFired = true;
+};
+const injectRouterInLinkComponent = (routerOptions) => {
+  if (routerOptions.injectRouterInLinkComponent) {
+    return (0, import_utils.deepMerge)(import_uikit.Link, import_uikit.RouterLink);
+  }
+};

package/dist/cjs/syncExtend.js

@@ -0,0 +1,47 @@
+"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, {
+  applyInspectListener: () => applyInspectListener,
+  applySyncDebug: () => applySyncDebug
+});
+module.exports = __toCommonJS(syncExtend_exports);
+var import_socket_ui = require("@symbo.ls/socket-ui");
+var import_env = require("@domql/env");
+var import_utils = require("@domql/utils");
+const applySyncDebug = (extend, options) => {
+  const { editor } = options;
+  if (!editor)
+    return extend;
+  const inspect = (0, import_utils.isUndefined)(editor.inspect) ? (0, import_env.isDevelopment)() : editor.inspect;
+  const liveSync = (0, import_utils.isUndefined)(editor.liveSync) ? (0, import_env.isDevelopment)() : editor.liveSync;
+  if (inspect)
+    extend.push(import_socket_ui.DevFocus);
+  if (liveSync)
+    extend.push(import_socket_ui.Sync);
+  return extend;
+};
+const applyInspectListener = (root, options) => {
+  const { editor } = options;
+  if (!editor)
+    return;
+  const inspect = (0, import_utils.isUndefined)(editor.inspect) ? (0, import_env.isDevelopment)() : editor.inspect;
+  if (inspect)
+    (0, import_socket_ui.inspectOnKey)(root);
+};

package/dist/cjs/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, {
+  init: () => import_init.init,
+  scratchSystem: () => import_scratch.scratchSystem,
+  scratchUtils: () => import_scratch.scratchUtils,
+  set: () => import_scratch.set,
+  updateReset: () => import_init.updateReset
+});
+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/utils"), module.exports);
+var import_init = require("@symbo.ls/init");
+__reExport(utilImports_exports, require("@domql/cookie"), module.exports);
+__reExport(utilImports_exports, require("@domql/report"), module.exports);
+__reExport(utilImports_exports, require("@domql/router"), module.exports);

package/package.json

@@ -1,10 +1,30 @@
 {
   "name": "@symbo.ls/create",
-  "version": "2.11.39",
+  "version": "2.11.98",
   "license": "MIT",
-  "gitHead": "2f40754c45ab3e9132e5335d3f01fcf7d2ac977b",
-  "source": "index.js",
-  "main": "index.js",
+  "gitHead": "fc4397b53ef569c55dba3e4dbe18a781a7884585",
+  "files": [
+    "src",
+    "dist"
+  ],
+  "repository": "https://github.com/symbo-ls/scratch",
+  "type": "module",
+  "module": "src/index.js",
+  "unpkg": "dist/iife/index.js",
+  "jsdelivr": "dist/iife/index.js",
+  "main": "src/index.js",
+  "exports": "./dist/cjs/index.js",
+  "source": "src/index.js",
+  "publishConfig": {},
+  "scripts": {
+    "copy:package:cjs": "cp ../../build/package-cjs.json dist/cjs/package.json",
+    "build:esm": "npx esbuild ./src/*.js --target=es2020 --format=esm --outdir=dist/esm",
+    "build:cjs": "npx esbuild ./src/*.js --target=node16 --format=cjs --outdir=dist/cjs",
+    "build:cjs:bundle": "npx esbuild ./src/index.js --target=node16 --format=cjs --outdir=dist/cjs/bundle --bundle",
+    "build:iife": "npx esbuild ./src/index.js --target=es2020 --format=iife --outdir=dist/iife --bundle --minify",
+    "build": "yarn build:cjs; yarn build:cjs:bundle",
+    "prepublish": "rimraf -I dist && yarn build && yarn copy:package:cjs"
+  },
   "dependencies": {
     "@domql/cookie": "latest",
     "@domql/emotion": "latest",