@netrojs/fnetro 0.1.5 → 0.2.0

package/dist/core.js

@@ -1,414 +1,4 @@
 // core.ts
-var RAW = /* @__PURE__ */ Symbol("raw");
-var IS_REACTIVE = /* @__PURE__ */ Symbol("isReactive");
-var IS_READONLY = /* @__PURE__ */ Symbol("isReadonly");
-var IS_REF = /* @__PURE__ */ Symbol("isRef");
-var MARK_RAW = /* @__PURE__ */ Symbol("markRaw");
-var targetMap = /* @__PURE__ */ new WeakMap();
-var activeEffect = null;
-var shouldTrack = true;
-var trackStack = [];
-function pauseTracking() {
-  trackStack.push(shouldTrack);
-  shouldTrack = false;
-}
-function resetTracking() {
-  shouldTrack = trackStack.pop() ?? true;
-}
-function track(target, key) {
-  if (!shouldTrack || !activeEffect) return;
-  let depsMap = targetMap.get(target);
-  if (!depsMap) targetMap.set(target, depsMap = /* @__PURE__ */ new Map());
-  let dep = depsMap.get(key);
-  if (!dep) depsMap.set(key, dep = /* @__PURE__ */ new Set());
-  trackEffect(activeEffect, dep);
-}
-function trackEffect(effect2, dep) {
-  if (!dep.has(effect2)) {
-    dep.add(effect2);
-    effect2.deps.push(dep);
-  }
-}
-function trigger(target, key, newVal, oldVal) {
-  const depsMap = targetMap.get(target);
-  if (!depsMap) return;
-  const effects = [];
-  const computedEffects = [];
-  depsMap.get(key)?.forEach((e) => {
-    if (e !== activeEffect) {
-      e.computed ? computedEffects.push(e) : effects.push(e);
-    }
-  });
-  [...computedEffects, ...effects].forEach((e) => {
-    if (e.active) e.scheduler ? e.scheduler() : e.run();
-  });
-}
-var ReactiveEffect = class {
-  constructor(fn, scheduler, scope) {
-    this.fn = fn;
-    this.scheduler = scheduler;
-    this.scope = scope;
-    scope?.effects.push(this);
-  }
-  deps = [];
-  active = true;
-  cleanup;
-  computed = false;
-  run() {
-    if (!this.active) return this.fn();
-    const prevEffect = activeEffect;
-    const prevShouldTrack = shouldTrack;
-    shouldTrack = true;
-    activeEffect = this;
-    this.cleanup?.();
-    this.cleanup = void 0;
-    this.deps.length = 0;
-    try {
-      const result = this.fn();
-      if (typeof result === "function") this.cleanup = result;
-      return result;
-    } finally {
-      activeEffect = prevEffect;
-      shouldTrack = prevShouldTrack;
-    }
-  }
-  stop() {
-    if (this.active) {
-      cleanupEffect(this);
-      this.active = false;
-    }
-  }
-};
-function cleanupEffect(e) {
-  e.deps.forEach((dep) => dep.delete(e));
-  e.deps.length = 0;
-}
-var activeScope;
-var EffectScope = class {
-  effects = [];
-  cleanups = [];
-  active = true;
-  run(fn) {
-    const prev = activeScope;
-    activeScope = this;
-    try {
-      return fn();
-    } finally {
-      activeScope = prev;
-    }
-  }
-  stop() {
-    if (this.active) {
-      this.effects.forEach((e) => e.stop());
-      this.cleanups.forEach((fn) => fn());
-      this.active = false;
-    }
-  }
-  onCleanup(fn) {
-    this.cleanups.push(fn);
-  }
-};
-function effectScope() {
-  return new EffectScope();
-}
-function getCurrentScope() {
-  return activeScope;
-}
-function onScopeDispose(fn) {
-  activeScope?.onCleanup(fn);
-}
-function effect(fn) {
-  const e = new ReactiveEffect(fn, void 0, activeScope);
-  e.run();
-  return () => e.stop();
-}
-function watchEffect(fn, opts) {
-  const e = new ReactiveEffect(fn, void 0, activeScope);
-  e.run();
-  return () => e.stop();
-}
-var refTarget = /* @__PURE__ */ Symbol("refTarget");
-var RefImpl = class {
-  constructor(value, shallow = false) {
-    this.shallow = shallow;
-    this._value = shallow ? value : toReactive(value);
-  }
-  [IS_REF] = true;
-  _value;
-  _subscribers = /* @__PURE__ */ new Set();
-  get value() {
-    track(this, refTarget);
-    this._subscribers.forEach((fn) => {
-    });
-    return this._value;
-  }
-  set value(next) {
-    const newVal = this.shallow ? next : toReactive(next);
-    if (!hasChanged(newVal, this._value)) return;
-    this._value = newVal;
-    trigger(this, refTarget, newVal, this._value);
-    this._subscribers.forEach((fn) => fn());
-  }
-  /** Subscribe for useSyncExternalStore */
-  subscribe(fn) {
-    this._subscribers.add(fn);
-    return () => this._subscribers.delete(fn);
-  }
-  peek() {
-    return this._value;
-  }
-};
-function ref(value) {
-  return isRef(value) ? value : new RefImpl(value);
-}
-function shallowRef(value) {
-  return new RefImpl(value, true);
-}
-function triggerRef(r) {
-  if (r instanceof RefImpl) {
-    trigger(r, refTarget);
-    r._subscribers.forEach((fn) => fn());
-  }
-}
-function isRef(r) {
-  return !!r && typeof r === "object" && r[IS_REF] === true;
-}
-function unref(r) {
-  return isRef(r) ? r.value : r;
-}
-function toRef(obj, key) {
-  const r = new RefImpl(void 0, false);
-  Object.defineProperty(r, "value", {
-    get() {
-      track(r, refTarget);
-      return obj[key];
-    },
-    set(v) {
-      obj[key] = v;
-      trigger(r, refTarget, v, obj[key]);
-    }
-  });
-  return r;
-}
-function toRefs(obj) {
-  const result = {};
-  for (const key in obj) result[key] = toRef(obj, key);
-  return result;
-}
-var ComputedRefImpl = class {
-  constructor(getter, setter) {
-    this.setter = setter;
-    this.effect = new ReactiveEffect(getter, () => {
-      if (!this._dirty) {
-        this._dirty = true;
-        trigger(this, refTarget);
-        this._subscribers.forEach((fn) => fn());
-      }
-    }, activeScope);
-    this.effect.computed = true;
-  }
-  [IS_REF] = true;
-  effect;
-  _value;
-  _dirty = true;
-  _subscribers = /* @__PURE__ */ new Set();
-  get value() {
-    track(this, refTarget);
-    if (this._dirty) {
-      this._dirty = false;
-      this._value = this.effect.run();
-    }
-    return this._value;
-  }
-  set value(v) {
-    this.setter?.(v);
-  }
-  subscribe(fn) {
-    this._subscribers.add(fn);
-    return () => this._subscribers.delete(fn);
-  }
-  peek() {
-    return this._value;
-  }
-};
-function computed(arg) {
-  if (typeof arg === "function") {
-    return new ComputedRefImpl(arg);
-  }
-  return new ComputedRefImpl(arg.get, arg.set);
-}
-var reactiveMap = /* @__PURE__ */ new WeakMap();
-var readonlyMap = /* @__PURE__ */ new WeakMap();
-var shallowReactiveMap = /* @__PURE__ */ new WeakMap();
-function toReactive(value) {
-  return value !== null && typeof value === "object" ? reactive(value) : value;
-}
-var arrayInstrumentations = {};
-["includes", "indexOf", "lastIndexOf"].forEach((method) => {
-  arrayInstrumentations[method] = function(...args) {
-    const arr = toRaw(this);
-    for (let i = 0; i < this.length; i++) track(arr, i);
-    let res = arr[method](...args);
-    if (res === -1 || res === false) res = arr[method](...args.map(toRaw));
-    return res;
-  };
-});
-["push", "pop", "shift", "unshift", "splice"].forEach((method) => {
-  arrayInstrumentations[method] = function(...args) {
-    pauseTracking();
-    const res = toRaw(this)[method].apply(this, args);
-    resetTracking();
-    return res;
-  };
-});
-function createHandler(shallow = false, readonly2 = false) {
-  return {
-    get(target, key, receiver) {
-      if (key === RAW) return target;
-      if (key === IS_REACTIVE) return !readonly2;
-      if (key === IS_READONLY) return readonly2;
-      if (key === MARK_RAW) return target[MARK_RAW];
-      const isArray = Array.isArray(target);
-      if (!readonly2 && isArray && hasOwn(arrayInstrumentations, key)) {
-        return Reflect.get(arrayInstrumentations, key, receiver);
-      }
-      const res = Reflect.get(target, key, receiver);
-      if (typeof key === "symbol" || key === "__proto__") return res;
-      if (!readonly2) track(target, key);
-      if (shallow) return res;
-      if (isRef(res)) return isArray ? res : res.value;
-      return res !== null && typeof res === "object" && !res[MARK_RAW] ? readonly2 ? readonlyProxy(res) : reactive(res) : res;
-    },
-    set(target, key, value, receiver) {
-      if (readonly2) {
-        console.warn(`[fnetro] Cannot set "${String(key)}" on readonly object`);
-        return true;
-      }
-      const oldVal = target[key];
-      const result = Reflect.set(target, key, value, receiver);
-      if (hasChanged(value, oldVal)) trigger(target, key, value, oldVal);
-      return result;
-    },
-    deleteProperty(target, key) {
-      if (readonly2) return true;
-      const hadKey = hasOwn(target, key);
-      const result = Reflect.deleteProperty(target, key);
-      if (hadKey && result) trigger(target, key);
-      return result;
-    },
-    has(target, key) {
-      const res = Reflect.has(target, key);
-      track(target, key);
-      return res;
-    },
-    ownKeys(target) {
-      track(target, Array.isArray(target) ? "length" : "__iterate__");
-      return Reflect.ownKeys(target);
-    }
-  };
-}
-function reactive(target) {
-  if (isReadonly(target)) return target;
-  if (target[MARK_RAW]) return target;
-  if (reactiveMap.has(target)) return reactiveMap.get(target);
-  const proxy = new Proxy(target, createHandler());
-  reactiveMap.set(target, proxy);
-  return proxy;
-}
-function shallowReactive(target) {
-  if (shallowReactiveMap.has(target)) return shallowReactiveMap.get(target);
-  const proxy = new Proxy(target, createHandler(true));
-  shallowReactiveMap.set(target, proxy);
-  return proxy;
-}
-function readonlyProxy(target) {
-  if (readonlyMap.has(target)) return readonlyMap.get(target);
-  const proxy = new Proxy(target, createHandler(false, true));
-  readonlyMap.set(target, proxy);
-  return proxy;
-}
-function readonly(target) {
-  return readonlyProxy(target);
-}
-function markRaw(value) {
-  ;
-  value[MARK_RAW] = true;
-  return value;
-}
-function toRaw(observed) {
-  const raw = observed?.[RAW];
-  return raw ? toRaw(raw) : observed;
-}
-function isReactive(value) {
-  if (isReadonly(value)) return isReactive(value[RAW]);
-  return !!(value && value[IS_REACTIVE]);
-}
-function isReadonly(value) {
-  return !!(value && value[IS_READONLY]);
-}
-function traverse(value, seen = /* @__PURE__ */ new Set()) {
-  if (!value || typeof value !== "object" || seen.has(value)) return value;
-  seen.add(value);
-  if (isRef(value)) {
-    traverse(value.value, seen);
-    return value;
-  }
-  if (Array.isArray(value)) {
-    value.forEach((v) => traverse(v, seen));
-    return value;
-  }
-  for (const key in value) traverse(value[key], seen);
-  return value;
-}
-function normalizeSource(src) {
-  if (Array.isArray(src)) return () => src.map((s) => isRef(s) ? s.value : s());
-  if (isRef(src)) return () => src.value;
-  return src;
-}
-function watch(source, cb, opts = {}) {
-  const getter = opts.deep ? () => traverse(normalizeSource(source)()) : normalizeSource(source);
-  let oldVal = void 0;
-  let cleanupFn;
-  const cleanup = (fn) => {
-    cleanupFn = fn;
-  };
-  const job = () => {
-    if (!effect2.active) return;
-    cleanupFn?.();
-    cleanupFn = void 0;
-    const newVal = effect2.run();
-    if (opts.deep || hasChanged(newVal, oldVal)) {
-      cb(newVal, oldVal, cleanup);
-      oldVal = newVal;
-    }
-    if (opts.once) effect2.stop();
-  };
-  const effect2 = new ReactiveEffect(getter, job, activeScope);
-  if (opts.immediate) {
-    cleanupFn?.();
-    cleanupFn = void 0;
-    const val = effect2.run();
-    cb(val, oldVal, cleanup);
-    oldVal = val;
-  } else {
-    oldVal = effect2.run();
-  }
-  return () => effect2.stop();
-}
-var __hooks = {
-  useValue: (r) => isRef(r) ? r.value : r(),
-  useLocalRef: (init) => ref(init),
-  useLocalReactive: (init) => reactive(init)
-};
-function use(source) {
-  return __hooks.useValue(source);
-}
-function useLocalRef(init) {
-  return __hooks.useLocalRef(init);
-}
-function useLocalReactive(init) {
-  return __hooks.useLocalReactive(init);
-}
 function definePage(def) {
   return { __type: "page", ...def };
 }
@@ -418,9 +8,6 @@ function defineGroup(def) {
 function defineLayout(Component) {
   return { __type: "layout", Component };
 }
-function defineMiddleware(handler) {
-  return { __type: "middleware", handler };
-}
 function defineApiRoute(path, register) {
   return { __type: "api", path, register };
 }
@@ -438,58 +25,50 @@ function resolveRoutes(routes, options = {}) {
       pages.push(...sub.pages);
       apis.push(...sub.apis);
     } else {
-      const fullPath = (options.prefix ?? "") + route.path;
-      const layout = route.layout !== void 0 ? route.layout : options.layout;
-      const middleware = [...options.middleware ?? [], ...route.middleware ?? []];
-      pages.push({ fullPath, page: route, layout, middleware });
+      pages.push({
+        fullPath: (options.prefix ?? "") + route.path,
+        page: route,
+        layout: route.layout !== void 0 ? route.layout : options.layout,
+        middleware: [...options.middleware ?? [], ...route.middleware ?? []]
+      });
     }
   }
   return { pages, apis };
 }
+function compilePath(path) {
+  const keys = [];
+  const src = path.replace(/\[\.\.\.([^\]]+)\]/g, (_, k) => {
+    keys.push(k);
+    return "(.*)";
+  }).replace(/\[([^\]]+)\]/g, (_, k) => {
+    keys.push(k);
+    return "([^/]+)";
+  }).replace(/\*/g, "(.*)");
+  return { re: new RegExp(`^${src}$`), keys };
+}
+function matchPath(compiled, pathname) {
+  const m = pathname.match(compiled.re);
+  if (!m) return null;
+  const params = {};
+  compiled.keys.forEach((k, i) => {
+    params[k] = decodeURIComponent(m[i + 1] ?? "");
+  });
+  return params;
+}
 var SPA_HEADER = "x-fnetro-spa";
 var STATE_KEY = "__FNETRO_STATE__";
 var PARAMS_KEY = "__FNETRO_PARAMS__";
-function hasChanged(a, b) {
-  return !Object.is(a, b);
-}
-function hasOwn(obj, key) {
-  return Object.prototype.hasOwnProperty.call(obj, key);
-}
+var SEO_KEY = "__FNETRO_SEO__";
 export {
-  EffectScope,
   PARAMS_KEY,
-  ReactiveEffect,
+  SEO_KEY,
   SPA_HEADER,
   STATE_KEY,
-  __hooks,
-  computed,
+  compilePath,
   defineApiRoute,
   defineGroup,
   defineLayout,
-  defineMiddleware,
   definePage,
-  effect,
-  effectScope,
-  getCurrentScope,
-  isReactive,
-  isReadonly,
-  isRef,
-  markRaw,
-  onScopeDispose,
-  reactive,
-  readonly,
-  ref,
-  resolveRoutes,
-  shallowReactive,
-  shallowRef,
-  toRaw,
-  toRef,
-  toRefs,
-  triggerRef,
-  unref,
-  use,
-  useLocalReactive,
-  useLocalRef,
-  watch,
-  watchEffect
+  matchPath,
+  resolveRoutes
 };