@symbo.ls/create 2.10.161 → 2.10.163

package/ferchOnCreate.js

@@ -0,0 +1,26 @@
+'use strict'
+
+import { fetchProject, fetchStateAsync } from "@symbo.ls/fetch"
+
+export const fetchSync = async (key, options) => {
+  if (key && options.editor) {
+    try {
+      if (!options.async) await fetchProject(key, options)
+    } catch (e) {
+      console.error(e)
+    }
+  }
+}
+
+export const fetchAsync = (app, key, options, callback) => {
+  if (key && options.editor) {
+    try {
+      if (options.editor.async) fetchStateAsync(key, options, (data) => {
+        app.state.update(data)
+      })
+    } catch (e) {
+      console.error(e)
+    }
+  }
+}
+

package/index.js

@@ -1,22 +1,23 @@
 'use strict'
 
 import DOM from 'domql'
-import { transformDOMQLEmotion } from 'domql/packages/emotion'
-import { router } from 'domql/packages/router'
+import { transformDOMQLEmotion } from '@domql/emotion'
+import { router as defaultRouter } from '@domql/router'
 
 import * as utils from '@symbo.ls/utils'
 import * as domqlUtils from '@domql/utils'
 
 import * as uikit from '@symbo.ls/uikit'
 import { init } from '@symbo.ls/init'
-import { fetchStateAsync, fetchProject } from '@symbo.ls/fetch'
 
 import { emotion as defaultEmotion, createEmotion } from '@symbo.ls/emotion'
 import { defaultDefine } from './define'
 
 import DYNAMIC_JSON from '@symbo.ls/init/dynamic.json'
+
 import { deepMerge, isObject } from '@domql/utils'
 import { initRouter } from './router'
+import { fetchAsync, fetchSync } from './ferchOnCreate'
 
 const SYMBOLS_KEY = process.env.SYMBOLS_KEY
 
@@ -55,22 +56,16 @@ export const create = async (App, options = defaultOptions, RC_FILE) => {
   const key = options.key || SYMBOLS_KEY || (appIsKey ? App : '')
 
   if (appIsKey) App = {}
-  if (key && options.editor) {
-    try {
-      if (!options.async) await fetchProject(key, options)
-    } catch (e) {
-      console.error(e)
-    }
-  }
+  await fetchSync(key, options)
 
   const initOptions = options.initOptions || {}
   const emotion = initOptions.emotion || defaultEmotion || createEmotion()
   if (!initOptions.emotion) initOptions.emotion = emotion
   const emotionDefine = options.registry || transformDOMQLEmotion(initOptions.emotion, options)
 
-  const doc = options.parent || document
+  const doc = options.parent || options.document || document
 
-  const designSystem = init(options.designSystem || {}, {
+  const scratchSystem = init(options.designSystem || {}, {
     key,
     emotion,
     verbose: options.verbose,
@@ -79,22 +74,31 @@ export const create = async (App, options = defaultOptions, RC_FILE) => {
     ...initOptions
   })
 
-  if (options.router) initRouter(App, options.router)
+  initRouter(App, options.routerOptions)
+
+  const state = options.state || {}
+  const pages =  options.pages || {}
+  const components = options.components ? { ...uikit, ...options.components } : uikit
+  const designSystem = scratchSystem || {}
+  const snippets = { ...utils, ...domqlUtils, ...(options.snippets || {})}
+  const router = options.router || defaultRouter
+  const define = options.define || defaultDefine
 
   const domqlApp = DOM.create({
     extend: [App],
     routes: options.pages,
-    state: options.state,
+    state,
     context: {
       key,
-      components: options.components ? { ...uikit, ...options.components } : uikit,
-      state: options.state || {},
-      pages: options.pages || {},
-      designSystem: designSystem || {},
-      utils: { ...utils, ...domqlUtils },
-      define: defaultDefine,
+      components,
+      state,
+      pages,
+      designSystem,
+      snippets,
+      utils: snippets,
+      define,
       registry: emotionDefine,
-      router: options.router || router,
+      router,
       emotion,
       document: doc
     }
@@ -104,15 +108,7 @@ export const create = async (App, options = defaultOptions, RC_FILE) => {
     ...options.domqlOptions
   })
 
-  if (key && options.editor) {
-    try {
-      if (options.editor.async) fetchStateAsync(key, options, (data) => {
-        domqlApp.state.update(data)
-      })
-    } catch (e) {
-      console.error(e)
-    }
-  }
+  fetchAsync(domqlApp)
 
   return domqlApp
 }

package/package.json

@@ -1,16 +1,21 @@
 {
   "name": "@symbo.ls/create",
-  "version": "2.10.161",
+  "version": "2.10.163",
   "license": "MIT",
-  "gitHead": "f9ad1b5f9b5230f9219b31df4b6b4b451d5dfa8f",
+  "gitHead": "9b654d48bb8ba26e3b1b7095b5ed7b813b61e1e0",
   "source": "index.js",
   "main": "index.js",
   "dependencies": {
+    "@domql/emotion": "latest",
+    "@domql/router": "latest",
     "@domql/utils": "latest",
     "@symbo.ls/fetch": "latest",
     "@symbo.ls/init": "latest",
     "@symbo.ls/uikit": "latest",
     "@symbo.ls/utils": "latest",
     "domql": "latest"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.12.0"
   }
 }

package/router.js

@@ -13,15 +13,15 @@ export const initRouter = (root, options = DEFAULT_ROUTING_OPTIONS) => {
   if (options === true) options = DEFAULT_ROUTING_OPTIONS
 
   const onRender = (el, s) => {
-    router(el, window.location.pathname, {}, { updateState: false })
+    router(el, window.location.pathname, {})
   }
 
   if (options.initRouter) {
     if (root.on) {
-      root.on.render = onRender
+      root.on.renderRouter = onRender
     } else {
       root.on = {
-        render: onRender
+        renderRouter: onRender
       }
     }
   }