@lark.js/mvc 0.0.5 → 0.0.6

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/constants.ts
 var globalCounter = 0;
-var SPLITTER = "";
+var SPLITTER = String.fromCharCode(30);
 var RouterEvents = {
   CHANGE: "change",
   CHANGED: "changed",
@@ -305,7 +305,7 @@ function safeguard(data, getter, setter, isRoot) {
       set(target, property, value) {
         if (!setter && !prefix) {
           throw new Error(
-            "Avoid write back, key: " + prefix + property + " value:" + value + " more: https://github.com/hangtiancheng/h"
+            "Avoid write back, key: " + prefix + property + " value:" + value + " more: https://github.com/hangtiancheng/lark"
           );
         }
         Reflect.set(target, property, value);
@@ -767,6 +767,7 @@ var cachedDefaultPath;
 var cachedRewrite;
 var defaultTitle;
 var frameworkConfig;
+var routeMode = "history";
 var beforeEachGuards = [];
 function createEmptyLocation() {
   return {
@@ -792,7 +793,8 @@ function attachViewAndPath(loc) {
     cachedRewrite = frameworkConfig.rewrite;
   }
   if (!loc.view) {
-    let path = loc.hash["path"] || cachedDefaultPath || "/";
+    const rawPath = routeMode === "history" ? loc.query["path"] || loc.hash["path"] : loc.hash["path"];
+    let path = rawPath || cachedDefaultPath || "/";
     if (cachedRewrite) {
       path = cachedRewrite(
         path,
@@ -858,7 +860,16 @@ function getChanged(oldLoc, newLoc) {
   changedCache.set(tKey, finalResult);
   return finalResult;
 }
-function updateHash(path, replace) {
+function updateBrowserUrl(path, replace) {
+  if (routeMode === "history") {
+    const url = path || "/";
+    if (replace) {
+      window.history.replaceState(null, "", url);
+    } else {
+      window.history.pushState(null, "", url);
+    }
+    return;
+  }
   const hashbang = frameworkConfig?.hashbang || "#!";
   const fullPath = path === "" ? "" : hashbang + path;
   if (replace) {
@@ -869,9 +880,10 @@ function updateHash(path, replace) {
 }
 function updateUrl(path, params, loc, replace, silentFlag, lQuery) {
   path = toUri(path, params, lQuery);
-  if (path !== loc.srcHash) {
+  const currentSrc = routeMode === "history" ? loc.srcQuery : loc.srcHash;
+  if (path !== currentSrc) {
     silent = silentFlag ? 1 : 0;
-    updateHash(path, replace);
+    updateBrowserUrl(path, replace);
   }
 }
 var Router = {
@@ -885,10 +897,29 @@ var Router = {
     if (cached) {
       return cached;
     }
-    const srcQuery = href.replace(URL_TRIM_HASH_REGEXP, "");
-    const srcHash = href.replace(URL_TRIM_QUERY_REGEXP, "");
-    const query = parseUri(srcQuery);
-    const hash = parseUri(srcHash);
+    let srcQuery;
+    let srcHash;
+    let query;
+    let hash;
+    if (routeMode === "history") {
+      try {
+        const urlObj = new URL(href, window.location.origin);
+        srcQuery = urlObj.pathname + urlObj.search;
+        srcHash = urlObj.hash ? urlObj.hash.replace(/^#!?/, "") : "";
+        query = parseUri(srcQuery);
+        hash = srcHash ? parseUri(srcHash) : { path: "", params: {} };
+      } catch {
+        srcQuery = href.replace(URL_TRIM_HASH_REGEXP, "");
+        srcHash = href.replace(URL_TRIM_QUERY_REGEXP, "");
+        query = parseUri(srcQuery);
+        hash = parseUri(srcHash);
+      }
+    } else {
+      srcQuery = href.replace(URL_TRIM_HASH_REGEXP, "");
+      srcHash = href.replace(URL_TRIM_QUERY_REGEXP, "");
+      query = parseUri(srcQuery);
+      hash = parseUri(srcHash);
+    }
     const params = assign({}, query["params"], hash["params"]);
     const location = {
       href,
@@ -962,7 +993,7 @@ var Router = {
       }
     }
     if (tPath) {
-      if (!hasOwnProperty(window, "history")) {
+      if (routeMode === "hash" && !hasOwnProperty(window, "history")) {
         for (const qKey of lQuery) {
           if (!hasOwnProperty(tParams, qKey)) {
             tParams[qKey] = "";
@@ -1014,32 +1045,41 @@ var Router = {
     return Router;
   },
   /**
-   * Internal: bind hashchange and beforeunload events.
+   * Internal: bind routing events and beforeunload.
    * Called by Framework.boot().
+   * In hash mode, listens to hashchange + popstate.
+   * In history mode, listens to popstate only.
    */
   _bind() {
     defaultTitle = document.title;
-    let lastHash = Router.parse().srcHash;
+    const getLocationKey = () => {
+      if (routeMode === "history") {
+        return window.location.pathname + window.location.search;
+      }
+      return Router.parse().srcHash;
+    };
+    let lastKey = getLocationKey();
     let suspend;
     const watchChange = () => {
       if (suspend) {
         return;
       }
+      hrefCache.clear();
       const loc = Router.parse();
-      const newHash = loc.srcHash;
-      if (newHash !== lastHash) {
+      const newKey = routeMode === "history" ? loc.srcQuery : loc.srcHash;
+      if (newKey !== lastKey) {
         const changeEvent = {
           p: 0,
           reject: () => {
             changeEvent.p = 1;
             suspend = "";
-            updateHash(lastHash);
+            updateBrowserUrl(lastKey);
           },
           resolve: () => {
             changeEvent.p = 1;
-            lastHash = newHash;
+            lastKey = newKey;
             suspend = "";
-            updateHash(newHash);
+            updateBrowserUrl(newKey);
             Router.diff();
           },
           prevent: () => {
@@ -1083,8 +1123,12 @@ var Router = {
       }
     };
     Router.notify = watchChange;
-    window.addEventListener("hashchange", watchChange);
-    window.addEventListener("popstate", watchChange);
+    if (routeMode === "history") {
+      window.addEventListener("popstate", watchChange);
+    } else {
+      window.addEventListener("hashchange", watchChange);
+      window.addEventListener("popstate", watchChange);
+    }
     window.addEventListener("beforeunload", (domEvent) => {
       const data = {};
       Router.fire(RouterEvents.PAGE_UNLOAD, data);
@@ -1100,11 +1144,15 @@ var Router = {
    */
   _setConfig(cfg) {
     frameworkConfig = cfg;
+    routeMode = cfg.routeMode || "history";
   }
 };
 function markRouterBooted() {
   booted2 = true;
 }
+function getRouteMode() {
+  return routeMode;
+}
 
 // src/event-delegator.ts
 var rootEvents = {};
@@ -2443,6 +2491,7 @@ function defineView(props, statics) {
 // src/module-loader.ts
 var config = {
   rootId: "root",
+  routeMode: "history",
   hashbang: "#!",
   error: (error) => {
     throw error;
@@ -3554,6 +3603,23 @@ var FrameVisualBridge = {
   MSG_TREE_DELTA: "LARK_VIS_TREE_DELTA"
 };
 function serializeView(view) {
+  const evtMap = view.eventObjectMap;
+  const eventMethodKeys = evtMap ? Object.keys(evtMap) : [];
+  const resourceKeys = view.resources ? Object.keys(view.resources) : [];
+  const lookup = view;
+  const hasAssign = typeof lookup["assign"] === "function";
+  let updaterData = null;
+  try {
+    const ref = view.updater?.refData;
+    if (ref && typeof ref === "object") {
+      updaterData = {};
+      for (const k of Object.keys(ref)) {
+        const v = ref[k];
+        updaterData[k] = v === null || typeof v !== "object" ? v : `[${typeof v}]`;
+      }
+    }
+  } catch {
+  }
   return {
     id: view.id,
     rendered: !!view.rendered,
@@ -3564,7 +3630,11 @@ function serializeView(view) {
       keys: view.locationObserved.keys,
       observePath: view.locationObserved.observePath
     },
-    hasTemplate: !!view.template
+    hasTemplate: !!view.template,
+    eventMethodKeys,
+    resourceKeys,
+    hasAssign,
+    updaterData
   };
 }
 function serializeFrame(frameId) {
@@ -4003,904 +4073,161 @@ if (typeof window !== "undefined") {
   window.__lark_registerViewClass = registerViewClass;
 }
 
-// src/store.ts
-var LARK_GLOBAL = "lark-global";
-var Platform = /* @__PURE__ */ ((Platform2) => {
-  Platform2["Lark"] = "lark";
-  Platform2["React"] = "react";
-  Platform2["Node"] = "node";
-  return Platform2;
-})(Platform || {});
-var isFunction = (val) => typeof val === "function";
-var isObject = (val) => val !== null && typeof val === "object";
-var isPromise = (val) => isObject(val) && isFunction(val["then"]);
-var hasOwnProperty2 = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop);
-var hasStructuredClone = typeof globalThis !== "undefined" && typeof globalThis.structuredClone === "function";
-var deepCloneFallback = (obj) => {
-  if (!obj || !isObject(obj)) return {};
-  const newData = Array.isArray(obj) ? [] : {};
-  for (const key in obj) {
-    if (hasOwnProperty2(obj, key)) {
-      const value = obj[key];
-      newData[key] = isObject(value) ? deepCloneFallback(value) : value;
-    }
-  }
-  return newData;
-};
-var deepClone = (obj) => {
-  if (hasStructuredClone) {
-    try {
-      return structuredClone(obj);
-    } catch {
-      return deepCloneFallback(obj);
-    }
-  }
-  return deepCloneFallback(obj);
-};
-var cloneData = (data) => isObject(data) ? deepClone(data) : data;
-var getDataByKey = (target, key) => {
-  if (!key.includes(".")) {
-    return target[key];
-  }
-  let data = target;
-  for (const k of key.split(".")) {
-    if (!isObject(data)) return void 0;
-    data = data[k];
-  }
-  return data;
-};
-var Queue = class {
-  pendingTasks = /* @__PURE__ */ new Set();
-  queue = [];
-  flushTasks() {
-    const { pendingTasks, queue } = this;
-    const flushTickTask = () => {
-      while (queue.length > 0) {
-        const task2 = queue.shift();
-        if (task2) {
-          pendingTasks.delete(task2);
-          runTask(task2);
-        }
-      }
-    };
-    Promise.resolve().then(flushTickTask);
-  }
-  add(tasks) {
-    const isQueueEmpty = this.queue.length === 0;
-    for (const { cb, params } of tasks) {
-      addParams2Callback(cb, params);
-      if (!this.pendingTasks.has(cb)) {
-        this.queue.push(cb);
-        this.pendingTasks.add(cb);
-      }
-    }
-    if (isQueueEmpty) this.flushTasks();
-  }
-  delete(tasks) {
-    if (this.pendingTasks.size === 0) return;
-    for (const { cb } of tasks) {
-      if (this.pendingTasks.has(cb)) {
-        this.pendingTasks.delete(cb);
-        const index = this.queue.findIndex((item) => item === cb);
-        if (index !== -1) this.queue.splice(index, 1);
-      }
-    }
-  }
-  clear() {
-    this.queue = [];
-    this.pendingTasks.clear();
-  }
-};
-var addParams2Callback = (cb, params) => {
-  if (!cb || !params) return;
-  const tagged = cb;
-  const existing = tagged.params;
-  if (isObject(existing)) {
-    Object.assign(existing, params);
-  } else {
-    tagged.params = params;
-  }
-};
-var runTask = (cb) => {
-  const tagged = cb;
-  const params = tagged.params;
-  delete tagged.params;
-  try {
-    cb(params);
-  } catch {
-  }
-};
-var getDefScheduler = () => new Queue();
-var run = (tasks, scheduler) => {
-  if (scheduler) {
-    if (isFunction(scheduler)) {
-      for (const { cb, params } of tasks) scheduler(cb, params);
-    } else {
-      scheduler.add(tasks);
+// src/url-state.ts
+function useUrlState(view, initialState) {
+  const keys2 = initialState ? Object.keys(initialState) : [];
+  if (keys2.length > 0) {
+    view.observeLocation(keys2);
+  }
+  const getState = () => {
+    const loc = Router.parse();
+    const result = { ...initialState || {} };
+    for (const key of keys2) {
+      const val = loc.get(key);
+      if (val) result[key] = val;
     }
-  } else {
-    for (const { cb, params } of tasks) cb(params);
-  }
-};
-var ArrMethods = {};
-["indexOf", "lastIndexOf", "includes"].forEach((key) => {
-  const rawMethod = Array.prototype[key];
-  ArrMethods[key] = function(...args) {
-    let res = rawMethod.apply(this, args);
-    if (res === -1 || res === false) {
-      res = rawMethod.apply(
-        this,
-        args.map(
-          (item) => isObject(item) ? ProxyCache.get(item) ?? item : item
-        )
-      );
-    }
-    return res;
-  };
-});
-var inArrUpdate = false;
-["unshift", "shift", "push", "pop", "splice"].forEach((key) => {
-  const rawMethod = Array.prototype[key];
-  ArrMethods[key] = function(...args) {
-    inArrUpdate = true;
-    const result = rawMethod.apply(this, args);
-    inArrUpdate = false;
     return result;
   };
-});
-function needKeepArrItem(target, newVal, key) {
-  if (!Array.isArray(target) || !inArrUpdate) return false;
-  if (!isObject(newVal)) return false;
-  return getLinkKeys(newVal) === createLinkKeys(target, key);
-}
-var defStateConfig = {
-  belong: LARK_GLOBAL,
-  linkKeys: "",
-  shallow: false
-};
-var StateConfigMap = /* @__PURE__ */ new WeakMap();
-var setStateConfig = (target, config2) => {
-  if (target && isObject(config2)) StateConfigMap.set(target, config2);
-};
-function getStateConfig(target, key) {
-  if (!StateConfigMap.has(target)) {
-    return void 0;
-  }
-  const config2 = StateConfigMap.get(target);
-  return key ? config2?.[key] : config2;
-}
-var isState = (target) => isObject(target) && StateConfigMap.has(target);
-var createLinkKeys = (target, property) => {
-  if (!hasLinkKeys(target)) return property;
-  if (Array.isArray(target)) return getLinkKeys(target) ?? property;
-  return `${getLinkKeys(target)}.${property}`;
-};
-var formatLinkKeys = (target, key) => {
-  const originKeysStr = getLinkKeys(target);
-  if (!originKeysStr) return null;
-  const linkKeys = [];
-  const originKeys = originKeysStr.split(".");
-  let pre = "";
-  for (const k of originKeys) {
-    const curr = pre ? `${pre}.${k}` : k;
-    linkKeys.push(curr);
-    pre = curr;
-  }
-  linkKeys.push(`${originKeysStr}.${key}`);
-  return linkKeys;
-};
-var getLinkKeys = (target) => getStateConfig(target, "linkKeys");
-var hasLinkKeys = (target) => !!getLinkKeys(target);
-var ProxyCache = /* @__PURE__ */ new WeakMap();
-var keepKey = null;
-var keep = (key) => {
-  if (keepKey) throw new Error("[lark-store] keepKey is not null");
-  keepKey = key;
-};
-var needKeep = (key) => {
-  if (keepKey === key) {
-    keepKey = null;
-    return true;
-  }
-  return false;
-};
-var canSetNewVal = (params) => {
-  const { property, newVal, oldVal } = params;
-  if (hasOwnProperty2(params.target, property) && newVal === oldVal)
-    return false;
-  return true;
-};
-var getNewVal = (params) => {
-  const { target, newVal, property, needKeepVal = false } = params;
-  const config2 = getStateConfig(target);
-  if (!isObject(newVal)) return newVal;
-  if (needKeepArrItem(target, newVal, property)) return newVal;
-  if (config2?.shallow) return newVal;
-  if (needKeepVal) return newVal;
-  const linkKeys = createLinkKeys(target, property);
-  const newState = createState(newVal, { ...config2, linkKeys });
-  if (isPromise(newVal)) handlePromise(newVal, target, property);
-  return newState;
-};
-var genPayload = (params) => {
-  const { target, property, newVal, oldVal } = params;
-  const config2 = getStateConfig(target) ?? defStateConfig;
-  return {
-    belong: config2.belong || LARK_GLOBAL,
-    target,
-    keys: formatLinkKeys(target, property) || [property],
-    newVal,
-    oldVal
+  const setState = (patch) => {
+    const current = getState();
+    const resolved = typeof patch === "function" ? patch(current) : patch;
+    Router.to(resolved);
   };
-};
-var handlePromise = (child, parent, key) => {
-  const childObj = child;
-  child.then((res) => {
-    const parentProxy = ProxyCache.get(parent);
-    if (parentProxy) {
-      const oldVal = parentProxy[key];
-      if (ProxyCache.get(childObj) === oldVal) {
-        parentProxy[key] = res;
-      }
-    }
-  }).catch((err) => {
-    const parentProxy = ProxyCache.get(parent);
-    if (parentProxy) {
-      const oldVal = parentProxy[key];
-      if (ProxyCache.get(childObj) === oldVal) {
-        parentProxy[key] = err;
-      }
-    }
-  });
-};
-var _deleteKey = "_delete";
-var _markObjKey = "_markObj";
-var mark2 = (host, key) => {
-  let sign;
-  if (!host[_deleteKey]) {
-    const markHost = host[_markObjKey] || (host[_markObjKey] = {});
-    if (!hasOwnProperty2(markHost, key)) {
-      markHost[key] = 0;
-    }
-    sign = ++markHost[key];
-  }
-  return () => {
-    const temp = host[_markObjKey];
-    return !!temp && sign === temp[key];
-  };
-};
-var unmark2 = (host) => {
-  host[_deleteKey] = 1;
-  host[_markObjKey] = 0;
-};
-function createState(initialData, config2) {
-  if (!isObject(initialData)) return initialData;
-  const mergedConfig = Object.assign({ ...defStateConfig }, config2);
-  const data = Array.isArray(initialData) ? [] : Object.create(Object.getPrototypeOf(initialData));
-  const handler = {
-    get(target, property, _receiver) {
-      if (Array.isArray(target) && property in ArrMethods) {
-        return ArrMethods[property];
-      }
-      return Reflect.get(target, property);
-    },
-    set(target, property, newVal, receiver) {
-      const strProp = property;
-      const oldVal = Reflect.get(target, property);
-      const preventTrigger = isLazySet(strProp);
-      const needKeepVal = needKeep(strProp);
-      const canSet = canSetNewVal({
-        target,
-        property: strProp,
-        newVal,
-        oldVal
-      });
-      if (!canSet) return true;
-      const proxyTarget = isObject(receiver) && receiver !== null ? receiver : state;
-      newVal = getNewVal({
-        target: proxyTarget,
-        property: strProp,
-        newVal,
-        needKeepVal
-      });
-      Reflect.set(target, property, newVal, receiver);
-      if (preventTrigger) return true;
-      const payload = genPayload({
-        target: proxyTarget,
-        property: strProp,
-        newVal,
-        oldVal
-      });
-      trigger(payload);
-      return true;
-    },
-    deleteProperty(target, property) {
-      const strProp = property;
-      if (!hasOwnProperty2(target, strProp)) return true;
-      const oldVal = Reflect.get(target, property);
-      Reflect.deleteProperty(target, property);
-      const payload = genPayload({
-        target: state,
-        property: strProp,
-        newVal: null,
-        oldVal
-      });
-      trigger(payload);
-      return true;
-    }
-  };
-  const state = new Proxy(data, handler);
-  ProxyCache.set(initialData, state);
-  setStateConfig(state, mergedConfig);
-  lazySet(state, initialData);
-  return state;
-}
-var curLazySetKey = null;
-function lazySet(target, data) {
-  if (isObject(data)) {
-    Reflect.ownKeys(data).forEach((key) => {
-      const strKey = key;
-      if (curLazySetKey) throw new Error("[lark-store] lazy set key conflict");
-      curLazySetKey = strKey;
-      target[strKey] = data[strKey];
-    });
-  }
-}
-function isLazySet(property) {
-  if (curLazySetKey === property) {
-    curLazySetKey = "";
-    return true;
-  }
-  return false;
-}
-function shallowSet(target, key, data) {
-  if (!isState(target))
-    throw new Error("[lark-store] shallowSet only supports state objects");
-  if (!isObject(data)) return target[key] = data;
-  keep(key);
-  const config2 = getStateConfig(target);
-  const linkKeys = createLinkKeys(target, key);
-  target[key] = createState(data, { ...config2, linkKeys, shallow: true });
-  return target[key];
+  return [getState(), setState];
 }
-var GlobalDeps = /* @__PURE__ */ new Map();
-function track(payload) {
-  const { belong, trackList = [] } = payload;
-  let deps = GlobalDeps.get(belong);
-  if (!deps) GlobalDeps.set(belong, deps = /* @__PURE__ */ new Map());
-  for (const { key, cb } of trackList) {
-    if (isFunction(cb)) {
-      let callbacks = deps.get(key);
-      if (!callbacks) deps.set(key, callbacks = /* @__PURE__ */ new Set());
-      callbacks.add(cb);
-    }
-  }
-}
-function trigger(payload) {
-  const { belong, keys: keys2 } = payload;
-  const store = getStore(belong);
-  if (store && store.status !== 2 /* ACTIVE */ && belong !== LARK_GLOBAL)
-    return;
-  const deps = GlobalDeps.get(belong);
-  if (!deps) return;
-  const tasks = /* @__PURE__ */ new Set();
-  for (const key of keys2) {
-    const callbacks = deps.get(key);
-    if (callbacks) {
-      for (const cb of callbacks) {
-        tasks.add({ cb, params: { [key]: true } });
-      }
-    }
-  }
-  if (tasks.size === 0) return;
-  const scheduler = store?.scheduler;
-  run(Array.from(tasks), scheduler);
+
+// src/store.ts
+var COMPUTED_BRAND = /* @__PURE__ */ Symbol("lark-store-computed");
+function isComputedMarker(val) {
+  return val !== null && typeof val === "object" && val[COMPUTED_BRAND] === true;
 }
-function clear(payload) {
-  if (!payload) {
-    GlobalDeps.clear();
-    return;
-  }
-  const { belong, clearList } = payload;
-  const deps = GlobalDeps.get(belong);
-  if (!deps) return;
-  const store = getStore(belong);
-  const scheduler = store?.scheduler;
-  if (clearList) {
-    for (const { key, cb } of clearList) {
-      const callbacks = deps.get(key);
-      if (callbacks) {
-        if (!cb) {
-          deps.delete(key);
-        } else if (callbacks.has(cb)) {
-          callbacks.delete(cb);
-          if (scheduler && !isFunction(scheduler)) {
-            scheduler.delete([{ cb }]);
-          }
-          if (callbacks.size === 0) deps.delete(key);
+function computed(deps, fn) {
+  return { [COMPUTED_BRAND]: true, deps, fn };
+}
+var storeRegistry = /* @__PURE__ */ new Map();
+function create(name, creator) {
+  const listeners = /* @__PURE__ */ new Set();
+  const computedDefs = /* @__PURE__ */ new Map();
+  const computedKeys = /* @__PURE__ */ new Set();
+  const actionKeys = /* @__PURE__ */ new Set();
+  let state;
+  let destroyed = false;
+  const getState = () => state;
+  const setState = (partial) => {
+    if (destroyed) return;
+    const prevState = state;
+    const resolved = typeof partial === "function" ? partial(prevState) : partial;
+    const nextState = { ...prevState };
+    let changed = false;
+    for (const key in resolved) {
+      if (Object.prototype.hasOwnProperty.call(resolved, key) && !computedKeys.has(key) && !actionKeys.has(key)) {
+        const newVal = resolved[key];
+        if (!Object.is(prevState[key], newVal)) {
+          nextState[key] = newVal;
+          changed = true;
         }
       }
     }
-  } else {
-    deps.clear();
-    GlobalDeps.delete(belong);
-    if (scheduler && !isFunction(scheduler)) {
-      scheduler.clear();
+    if (!changed) return;
+    state = nextState;
+    recomputeIfNeeded(prevState);
+    for (const listener of listeners) {
+      listener(state, prevState);
     }
-  }
-}
-var _storeName = /* @__PURE__ */ Symbol("store-name");
-var _storeStatus = /* @__PURE__ */ Symbol("store-status");
-var _storeScheduler = /* @__PURE__ */ Symbol("store-scheduler");
-var _storeCreate = /* @__PURE__ */ Symbol("fn:store-create");
-var _storeBoot = /* @__PURE__ */ Symbol("fn:store-boot");
-var _storeDestroy = /* @__PURE__ */ Symbol("fn:store-destroy");
-var _innerStore = /* @__PURE__ */ Symbol("inner-store");
-var _outerStore = /* @__PURE__ */ Symbol("outer-store");
-var _originState = /* @__PURE__ */ Symbol("origin-state");
-var _stateKeys = /* @__PURE__ */ Symbol("state-keys");
-var _storeState = /* @__PURE__ */ Symbol("store-state");
-var _storeDefScheduler = /* @__PURE__ */ Symbol("store-def-scheduler");
-var _storeProxy = /* @__PURE__ */ Symbol("fn:store-proxy");
-var _computedKeys = /* @__PURE__ */ Symbol("store-computed-keys");
-var COMPUTED_BRAND = /* @__PURE__ */ Symbol("store-computed-brand");
-function computed(deps, fn) {
-  const marker = {
-    [COMPUTED_BRAND]: true,
-    deps,
-    fn
   };
-  return marker;
-}
-function isComputedMarker(val) {
-  return isObject(val) && val[COMPUTED_BRAND] === true;
-}
-var BaseStore = class {
-  [_storeStatus] = 0 /* BEFORE_CREATE */;
-  [_computedKeys] = /* @__PURE__ */ new Set();
-  [_storeDefScheduler] = getDefScheduler;
-  [_storeBoot]() {
-    this[_storeStatus] = 2 /* ACTIVE */;
-    return this[_storeProxy](true);
-  }
-  [_storeDestroy]() {
-    clear({ belong: this[_storeName] });
-    this[_storeState] = createState(this[_originState], {
-      belong: this[_storeName]
-    });
-    this[_storeStatus] = 3 /* DESTROYED */;
-  }
-  /**
-   *
-   * @param body - The object returned by the creator function
-   * @param excludeFns - Function keys to exclude from handlers (e.g. ['observe'])
-   */
-  [_storeCreate](body, excludeFns = ["observe"]) {
-    this[_storeStatus] = 1 /* CREATED */;
-    if (isObject(body)) {
-      const state = {};
-      const handlers = {};
-      const computedDefs = {};
-      const computedKeys = this[_computedKeys];
-      Reflect.ownKeys(body).forEach((key) => {
-        const strKey = key;
-        const val = body[strKey];
-        if (isComputedMarker(val)) {
-          computedDefs[strKey] = val;
-          state[strKey] = void 0;
-          computedKeys.add(strKey);
-        } else if (isFunction(val)) {
-          if (!excludeFns.includes(strKey)) handlers[strKey] = val;
-        } else {
-          state[strKey] = val;
-        }
-      });
-      Object.assign(this, handlers);
-      this[_originState] = cloneData(state);
-      this[_stateKeys] = Object.keys(state);
-      this[_storeState] = createState(state, { belong: this[_storeName] });
-      if (Object.keys(computedDefs).length > 0) {
-        const belong = this[_storeName];
-        const storeState = this[_storeState];
-        for (const key of Object.keys(computedDefs)) {
-          const def = computedDefs[key];
-          const recompute = () => {
-            storeState[key] = def.fn();
-          };
-          recompute();
-          const trackList = def.deps.map((depKey) => ({
-            key: depKey,
-            cb: recompute
-          }));
-          if (trackList.length > 0) track({ belong, trackList });
+  const recomputeIfNeeded = (prevState) => {
+    if (computedDefs.size === 0) return;
+    const changedKeys2 = /* @__PURE__ */ new Set();
+    for (const key of Object.keys(state)) {
+      if (!Object.is(
+        state[key],
+        prevState[key]
+      )) {
+        changedKeys2.add(key);
+      }
+    }
+    let recomputed = false;
+    for (const [key, def] of computedDefs) {
+      if (def.deps.some((dep) => changedKeys2.has(dep))) {
+        const newVal = def.fn();
+        if (!Object.is(state[key], newVal)) {
+          state[key] = newVal;
+          recomputed = true;
         }
       }
     }
-  }
-  constructor(name, config2) {
-    this[_storeName] = name;
-    this[_storeScheduler] = config2?.scheduler || this[_storeDefScheduler]();
-    this[_outerStore] = this[_storeProxy](true);
-  }
-  [_innerStore]() {
-    return this[_storeProxy]();
-  }
-  get status() {
-    return this[_storeStatus];
-  }
-  get storeName() {
-    return this[_storeName];
-  }
-  get scheduler() {
-    return this[_storeScheduler];
-  }
-  [_storeProxy](toOut = false) {
-    const self = this;
-    const proxy = new Proxy(self, {
-      get(target, property) {
-        const strProp = property;
-        if (self[_stateKeys].includes(strProp)) {
-          const val = self[_storeState][strProp];
-          return toOut ? cloneData(val) : val;
-        }
-        return Reflect.get(target, property);
-      },
-      set(_target, property, val) {
-        if (toOut) return true;
-        const strProp = property;
-        if (self[_computedKeys].has(strProp)) return true;
-        if (self[_stateKeys].includes(strProp)) {
-          self[_storeState][strProp] = val;
-        }
-        return true;
-      },
-      has(target, property) {
-        return Reflect.has(target, property) || self[_stateKeys].includes(property);
-      }
-    });
-    return proxy;
-  }
-};
-var LarkUtils = {
-  isLarkView(instance) {
-    if (!isObject(instance)) return false;
-    const updater = instance["updater"];
-    return isObject(updater) && isFunction(updater["set"]) && isFunction(updater["digest"]);
-  },
-  getRender(view) {
-    return view.updater.digest.bind(view.updater);
-  },
-  getDataSetter(view) {
-    return view.updater.set.bind(view.updater);
-  },
-  onDestroy(view, cb) {
-    view.on("destroy", cb);
-  }
-};
-var getLarkAdapter = (storeName) => ({
-  Store: LarkStore,
-  useStore: ((view) => {
-    const store = getStore(storeName);
-    if (!(store instanceof LarkStore)) return {};
-    return store[_storeBoot](view);
-  })
-});
-var _innerObserveFlags = /* @__PURE__ */ Symbol("store-inner-observe-flags");
-var _boundViews = /* @__PURE__ */ Symbol("store-bound-views");
-var LarkStore = class extends BaseStore {
-  [_boundViews] = /* @__PURE__ */ new Set();
-  [_innerObserveFlags] = /* @__PURE__ */ new Set();
-  [_storeBoot](view) {
-    if (view && LarkUtils.isLarkView(view) && !this[_boundViews].has(view)) {
-      this[_boundViews].add(view);
-      LarkUtils.onDestroy(view, () => {
-        this[_boundViews].delete(view);
-      });
-    }
-    return super[_storeBoot]();
-  }
-  [_storeDestroy]() {
-    this[_boundViews].clear();
-    this[_innerObserveFlags].clear();
-    super[_storeDestroy]();
-  }
-  observe(view, keys2, defCallback) {
-    if (this[_storeStatus] !== 2 /* ACTIVE */) return noop;
-    let observeKeys = Array.isArray(keys2) ? keys2 : [];
-    const _view = view;
-    const renderFn = _view ? LarkUtils.getRender(_view) : noop;
-    const dateSetterFn = _view ? LarkUtils.getDataSetter(_view) : noop;
-    const isInnerObserve = !view;
-    const innerFlags = /* @__PURE__ */ new Set();
-    const storeInnerObserveFlags = this[_innerObserveFlags];
-    if (isFunction(keys2)) {
-      const res = keys2();
-      if (Array.isArray(res)) observeKeys = res;
-    }
-    if (keys2 === void 0 && _view && observeKeys.length === 0 && Array.isArray(this[_stateKeys])) {
-      observeKeys = this[_stateKeys].slice();
-    }
-    const defSetter = (immediate, key, alias, transform) => () => {
-      const stateVal = getDataByKey(this, key);
-      let data = { [alias || key]: stateVal };
-      if (transform && isFunction(transform)) {
-        const newData = transform(stateVal);
-        if (isObject(newData)) data = newData;
-      }
-      if (immediate) dateSetterFn(data);
-      else renderFn(data);
-    };
-    const getList = (immediate = false) => {
-      const list = [];
-      for (const item of observeKeys) {
-        if (!item) continue;
-        const payload = typeof item === "string" ? { key: item } : item;
-        const { cb: cbDefault = defCallback, key } = payload;
-        let cb = cbDefault;
-        const { alias, lazy = true, transform } = payload;
-        if (!key) continue;
-        const c1 = !immediate;
-        const c2 = !cb && !!_view;
-        const c3 = !!cb && String(lazy) === "false";
-        if (!(c1 || c2 || c3)) continue;
-        if (isInnerObserve && cb) {
-          const flag = `storeInner_${key}_${observeKeys.join("-")}_${cb.toString()}`;
-          if (!storeInnerObserveFlags.has(flag)) {
-            storeInnerObserveFlags.add(flag);
-            innerFlags.add(flag);
-          }
-        }
-        if (c2) cb = defSetter(immediate, key, alias, transform);
-        if (cb) list.push({ key, cb });
-      }
-      return list;
-    };
-    const trackList = getList();
-    track({ belong: this[_storeName], trackList });
-    if (_view) {
-      LarkUtils.onDestroy(
-        _view,
-        () => clear({ belong: this[_storeName], clearList: trackList })
-      );
+    if (recomputed) {
     }
-    if (!isInnerObserve) run(getList(true));
+  };
+  const subscribe = (listener) => {
+    listeners.add(listener);
     return () => {
-      clear({ belong: this[_storeName], clearList: trackList });
-      innerFlags.forEach((flag) => storeInnerObserveFlags.delete(flag));
+      listeners.delete(listener);
     };
-  }
-};
-var getReactAdapter = (storeName) => ({
-  Store: ReactStore,
-  useStore: (() => {
-    const store = getStore(storeName);
-    if (!(store instanceof ReactStore)) return {};
-    return store[_storeBoot]();
-  })
-});
-var _observe = /* @__PURE__ */ Symbol("store-observe");
-var _getLastState = /* @__PURE__ */ Symbol("store-get-last-state");
-var ReactStore = class extends BaseStore {
-  stateChangeCount = 0;
-  lastCount = 0;
-  lastState = null;
-  constructor(name, config2) {
-    const effectiveConfig = config2 && !config2.scheduler ? {
-      ...config2,
-      scheduler: (cb, params) => cb(params)
-    } : config2;
-    super(name, effectiveConfig);
-  }
-  [_storeCreate](body) {
-    super[_storeCreate](body);
-    this[_observe](() => {
-      this.stateChangeCount += 1;
-    });
-  }
-  isStateChanged() {
-    const currCount = this.stateChangeCount;
-    const changed = this.lastCount !== currCount;
-    this.lastCount = currCount;
-    return changed;
-  }
-  [_getLastState](handlers) {
-    if (this.isStateChanged() || !this.lastState) {
-      const state = this[_storeState];
-      const immutableState = freezeData(state);
-      this.lastState = Object.assign({}, handlers, immutableState);
-    }
-    return this.lastState;
-  }
-  [_observe](cb) {
-    const tasks = this[_stateKeys].map((key) => ({ key, cb }));
-    track({ belong: this[_storeName], trackList: tasks });
-    return () => clear({ belong: this[_storeName], clearList: tasks });
-  }
-};
-var freezeData = (target) => {
-  const data = {};
-  const keys2 = Object.keys(target);
-  for (const key of keys2) {
-    const value = target[key];
-    if (Array.isArray(value)) {
-      data[key] = value.map(
-        (item) => isObject(item) ? freezeData(item) : item
-      );
-    } else if (isObject(value)) {
-      data[key] = freezeData(value);
+  };
+  const destroy = () => {
+    destroyed = true;
+    listeners.clear();
+    storeRegistry.delete(name);
+  };
+  const api = { getState, setState, subscribe, destroy };
+  const body = creator(setState, getState);
+  const initialState = {};
+  const actions = {};
+  for (const key of Object.keys(body)) {
+    const val = body[key];
+    if (isComputedMarker(val)) {
+      computedDefs.set(key, val);
+      computedKeys.add(key);
+      initialState[key] = void 0;
+    } else if (typeof val === "function") {
+      actions[key] = val;
+      actionKeys.add(key);
     } else {
-      data[key] = value;
+      initialState[key] = val;
     }
   }
-  return data;
-};
-var getNodeAdapter = (storeName) => ({
-  Store: NodeStore,
-  useStore: (() => {
-    const store = getStore(storeName);
-    if (!(store instanceof NodeStore)) return {};
-    return store[_storeBoot]();
-  })
-});
-var NodeStore = class extends BaseStore {
-  observe(key, callback, immediate = true) {
-    const tasks = [{ key, cb: callback }];
-    track({ belong: this[_storeName], trackList: tasks });
-    if (immediate) run(tasks);
-    return () => clear({ belong: this[_storeName], clearList: tasks });
+  state = { ...initialState, ...actions };
+  for (const [key, def] of computedDefs) {
+    state[key] = def.fn();
   }
-};
-var getAdapter = (platform, storeName) => {
-  switch (platform) {
-    case "react" /* React */:
-      return getReactAdapter(storeName);
-    case "node" /* Node */:
-      return getNodeAdapter(storeName);
-    case "lark" /* Lark */:
-    default:
-      return getLarkAdapter(storeName);
-  }
-};
-var getPlatform = (comp) => {
-  if (LarkUtils.isLarkView(comp)) return "lark" /* Lark */;
-  return void 0;
-};
-var extendApis = { lazySet, shallowSet, computed };
-var StoreCache = /* @__PURE__ */ new Map();
-function defineStore(name, creator, config2) {
-  if (StoreCache.has(name)) {
-    name = name + "_copy";
-  }
-  const { platform = "lark" /* Lark */ } = config2 || {};
-  const adapter = getAdapter(platform, name);
-  const StoreClass = adapter.Store;
-  const useStore = adapter.useStore;
-  const store = new StoreClass(name, config2);
-  const innerProxy = store[_innerStore]();
-  const body = creator(innerProxy, extendApis);
-  store[_storeCreate](body);
-  Object.defineProperties(useStore, {
-    $storeName: { value: name, configurable: true },
-    $destroyFn: { value: () => store[_storeDestroy](), configurable: true }
-  });
-  if (!StoreCache.has(name)) {
-    StoreCache.set(name, {
-      store,
-      creator,
-      config: config2,
-      useStore
-    });
-  }
-  return useStore;
+  storeRegistry.set(name, api);
+  return api;
 }
-function getStore(name) {
-  if (name && StoreCache.has(name)) {
-    const entry = StoreCache.get(name);
-    return entry ? entry.store : void 0;
-  }
-  return void 0;
-}
-function delStore(name) {
-  if (name && StoreCache.has(name)) StoreCache.delete(name);
-}
-function getUseStore(name) {
-  if (name && StoreCache.has(name)) {
-    const entry = StoreCache.get(name);
-    return entry ? entry.useStore : void 0;
-  }
-  return void 0;
-}
-function cloneStore(name, useStore, config2) {
-  const oldStoreName = useStore.$storeName ?? "";
-  const cached = StoreCache.get(oldStoreName);
-  const oldStoreCreator = cached?.creator;
-  const oldConfig = cached?.config || {};
-  if (!name || !oldStoreCreator) return;
-  const mergedConfig = { ...oldConfig, ...config2 || {} };
-  return defineStore(
-    name,
-    oldStoreCreator,
-    mergedConfig
-  );
+function isLarkView(instance) {
+  if (!instance || typeof instance !== "object") return false;
+  const obj = instance;
+  const updater = obj["updater"];
+  return updater !== null && typeof updater === "object" && typeof updater["set"] === "function" && typeof updater["digest"] === "function";
 }
-function isStoreActive(name) {
-  if (name && StoreCache.has(name)) {
-    const entry = StoreCache.get(name);
-    return entry ? entry.store.status === 2 /* ACTIVE */ : false;
-  }
-  return false;
-}
-var cellCount = 0;
-function cell(data) {
-  const linkKeys = `${LARK_GLOBAL}_${cellCount++}`;
-  return createState(data, { belong: LARK_GLOBAL, linkKeys });
-}
-function observeCell(state, cb, immediate = true) {
-  const linkKeys = getLinkKeys(state);
-  if (!linkKeys) return noop;
-  const keys2 = linkKeys.split(".");
-  const key = keys2[keys2.length - 1];
-  const list = [{ key, cb }];
-  track({ belong: LARK_GLOBAL, trackList: list });
-  if (immediate) cb();
-  return () => clear({ belong: LARK_GLOBAL, clearList: list });
-}
-function multi(useStore) {
-  const storeName = useStore.$storeName ?? "";
-  const flagSym = `lark-comp-${storeName}`;
-  const map = /* @__PURE__ */ new Map();
-  let rootViewPath;
-  const getFlag = (viewContext) => {
-    const owner = viewContext.owner;
-    const viewPath = owner?.path ?? "";
-    const viewId = owner?.id ?? "";
-    let flag;
-    if (viewPath === rootViewPath) {
-      flag = `${flagSym}-${viewId}`;
-    } else {
-      const initParams = owner?.viewInitParams;
-      const candidate = initParams?.[flagSym];
-      flag = typeof candidate === "string" ? candidate : void 0;
-    }
-    if (owner && isFunction(owner.mountFrame)) {
-      const rawMountFrame = owner.mountFrame;
-      owner.mountFrame = (frameId, viewPath2, viewInitParams = {}) => rawMountFrame.call(
-        owner,
-        frameId,
-        viewPath2,
-        Object.assign(viewInitParams, { [flagSym]: flag })
-      );
-    }
-    return flag ?? "";
+function bindStore(view, store, selector) {
+  if (!isLarkView(view)) return () => {
   };
-  const useFn = ((view) => {
-    if (!view)
-      throw new Error(
-        "[@lark.js/mvc error] multi: cannot find the view instance"
-      );
-    const viewCtx = view;
-    const tag = viewCtx[flagSym];
-    const flag = typeof tag === "string" ? tag : "";
-    if (map.has(flag)) return map.get(flag);
-    const newFn = cloneStore(flag, useStore);
-    map.set(flag, newFn);
-    return useFn(view);
-  });
-  const mixinObj = {
-    make() {
-      if (!rootViewPath) {
-        rootViewPath = this.owner?.path ?? "";
+  const extract = (s) => {
+    if (selector) return selector(s);
+    const result = {};
+    for (const key in s) {
+      if (Object.prototype.hasOwnProperty.call(s, key) && typeof s[key] !== "function") {
+        result[key] = s[key];
       }
-      this[flagSym] = getFlag(this);
     }
+    return result;
   };
-  return [useFn, mixinObj];
+  view.updater.set(extract(store.getState()));
+  view.updater.digest();
+  const off = store.subscribe((state) => {
+    view.updater.set(extract(state));
+    view.updater.digest();
+  });
+  view.on("destroy", off);
+  return off;
 }
+var defineStore = create;
 
 // src/compiler.ts
 import { parse as babelParse } from "@babel/parser";
-var SPLITTER2 = "";
-var VIEW_ID_PLACEHOLDER = "";
+var SPLITTER2 = String.fromCharCode(30);
+var VIEW_ID_PLACEHOLDER = String.fromCharCode(31);
 function jsObjectToUrlParams(paramsStr) {
   const trimmed = paramsStr.trim();
   if (!/^[{[]/.test(trimmed) && /=/.test(trimmed)) {
@@ -4960,7 +4287,7 @@ function addLineMarkers(source) {
     if (parts.length > 1) {
       const reconstructed = parts.map((part, i) => {
         if (i === 0) return part;
-        return openTag + SPLITTER2 + ++lineNo;
+        return openTag + SPLITTER2 + ++lineNo + part;
       }).join("");
       result.push(reconstructed);
     } else {
@@ -5353,7 +4680,7 @@ function extractGlobalVars(source) {
   const htmlStore = {};
   let htmlIndex = 0;
   let lastIndex = 0;
-  const htmlKey = "";
+  const htmlKey = String.fromCharCode(5);
   template.replace(
     templateCmdRegExp,
     (match, operate, content, offset) => {
@@ -5657,7 +4984,6 @@ export {
   Framework,
   LARK_VIEW,
   Payload,
-  Platform,
   RouterEvents as ROUTER_EVENTS,
   Router,
   SPLITTER,
@@ -5671,16 +4997,13 @@ export {
   applyStyle,
   applyVdomOps,
   assign,
-  cell,
-  cloneData,
-  cloneStore,
+  bindStore,
   compileTemplate,
   computed,
-  createState,
+  create,
   createVdomRef,
   defineStore,
   defineView,
-  delStore,
   encodeHTML,
   encodeQ,
   encodeSafe,
@@ -5692,43 +5015,34 @@ export {
   generateId,
   getAttribute,
   getById,
-  getPlatform,
-  getStore,
-  getUseStore,
+  getRouteMode,
   hasOwnProperty,
   installFrameVisualizerBridge,
   invalidateViewClass,
   isPlainObject,
   isPrimitive,
   isPrimitiveOrFunc,
-  isState,
-  isStoreActive,
   keys,
-  lazySet,
   mark,
   markBooted,
   markRouterBooted,
-  multi,
   nextCounter,
   nodeInside,
   noop,
   now,
-  observeCell,
   parseUri,
   registerViewClass,
   resetProjectsMap,
   safeguard,
   serializeFrameTree,
   setData,
-  shallowSet,
-  mark2 as storeMark,
-  unmark2 as storeUnmark,
   syncCounter,
   toMap,
   toUri,
   translateData,
   unmark,
   use,
+  useUrlState,
   vdomGetCompareKey,
   vdomGetNode,
   vdomSetAttributes,