@netrojs/fnetro 0.1.2

package/dist/core.d.ts

@@ -0,0 +1,200 @@
+import { Hono, MiddlewareHandler, Context } from 'hono';
+
+type EffectFn = () => void | (() => void);
+declare const IS_REF: unique symbol;
+declare class ReactiveEffect {
+    fn: () => any;
+    scheduler?: (() => void) | undefined;
+    scope?: EffectScope | undefined;
+    deps: Set<ReactiveEffect>[];
+    active: boolean;
+    cleanup?: () => void;
+    computed: boolean;
+    constructor(fn: () => any, scheduler?: (() => void) | undefined, scope?: EffectScope | undefined);
+    run(): any;
+    stop(): void;
+}
+declare class EffectScope {
+    effects: ReactiveEffect[];
+    cleanups: (() => void)[];
+    active: boolean;
+    run<T>(fn: () => T): T;
+    stop(): void;
+    onCleanup(fn: () => void): void;
+}
+declare function effectScope(): EffectScope;
+declare function getCurrentScope(): EffectScope | undefined;
+declare function onScopeDispose(fn: () => void): void;
+declare function effect(fn: EffectFn): () => void;
+interface WatchEffectOptions {
+    flush?: 'sync' | 'post';
+    onTrack?: (e: any) => void;
+    onTrigger?: (e: any) => void;
+}
+declare function watchEffect(fn: EffectFn, opts?: WatchEffectOptions): () => void;
+interface Ref<T = unknown> {
+    value: T;
+    readonly [IS_REF]: true;
+}
+declare function ref<T>(value: T): Ref<T>;
+declare function shallowRef<T>(value: T): Ref<T>;
+declare function triggerRef(r: Ref): void;
+declare function isRef<T = unknown>(r: unknown): r is Ref<T>;
+declare function unref<T>(r: T | Ref<T>): T;
+declare function toRef<T extends object, K extends keyof T>(obj: T, key: K): Ref<T[K]>;
+declare function toRefs<T extends object>(obj: T): {
+    [K in keyof T]: Ref<T[K]>;
+};
+interface WritableComputedRef<T> extends Ref<T> {
+    readonly effect: ReactiveEffect;
+}
+interface ComputedRef<T> extends WritableComputedRef<T> {
+    readonly value: T;
+}
+declare function computed<T>(getter: () => T): ComputedRef<T>;
+declare function computed<T>(opts: {
+    get: () => T;
+    set: (v: T) => void;
+}): WritableComputedRef<T>;
+declare function reactive<T extends object>(target: T): T;
+declare function shallowReactive<T extends object>(target: T): T;
+declare function readonly<T extends object>(target: T): Readonly<T>;
+declare function markRaw<T extends object>(value: T): T;
+declare function toRaw<T>(observed: T): T;
+declare function isReactive(value: unknown): boolean;
+declare function isReadonly(value: unknown): boolean;
+type WatchSource<T = unknown> = Ref<T> | ComputedRef<T> | (() => T);
+type MultiSource = WatchSource[] | readonly WatchSource[];
+type MapSources<T, Immediate = false> = {
+    [K in keyof T]: T[K] extends WatchSource<infer V> ? Immediate extends true ? V | undefined : V : T[K] extends object ? T[K] : never;
+};
+interface WatchOptions<Immediate = boolean> {
+    immediate?: Immediate;
+    deep?: boolean;
+    once?: boolean;
+}
+type StopHandle = () => void;
+type CleanupFn = (fn: () => void) => void;
+declare function watch<T>(source: WatchSource<T>, cb: (val: T, old: T | undefined, cleanup: CleanupFn) => void, opts?: WatchOptions): StopHandle;
+declare function watch<T extends MultiSource>(source: T, cb: (val: MapSources<T>, old: MapSources<T, true>, cleanup: CleanupFn) => void, opts?: WatchOptions): StopHandle;
+interface FNetroHooks {
+    useValue<T>(r: Ref<T> | (() => T)): T;
+    useLocalRef<T>(init: T): Ref<T>;
+    useLocalReactive<T extends object>(init: T): T;
+}
+declare const __hooks: FNetroHooks;
+/**
+ * Subscribe to a Ref or computed getter inside a JSX component.
+ * On the server, returns the current value (no reactivity needed).
+ * On the client, re-renders the component whenever the value changes.
+ *
+ * @example
+ * const count = ref(0)
+ * function Counter() {
+ *   const n = use(count)
+ *   return <button onClick={() => count.value++}>{n}</button>
+ * }
+ */
+declare function use<T>(source: Ref<T> | (() => T)): T;
+/**
+ * Create a component-local reactive Ref.
+ * Unlike module-level `ref()`, this is scoped to the component lifecycle.
+ *
+ * @example
+ * function Input() {
+ *   const text = useLocalRef('')
+ *   return <input value={use(text)} onInput={e => text.value = e.target.value} />
+ * }
+ */
+declare function useLocalRef<T>(init: T): Ref<T>;
+/**
+ * Create a component-local reactive object.
+ * @example
+ * function Form() {
+ *   const form = useLocalReactive({ name: '', email: '' })
+ *   return <input value={form.name} onInput={e => form.name = e.target.value} />
+ * }
+ */
+declare function useLocalReactive<T extends object>(init: T): T;
+type LoaderCtx = Context;
+type FNetroMiddleware = MiddlewareHandler;
+type AnyJSX = any;
+interface PageDef<TData extends object = {}> {
+    readonly __type: 'page';
+    path: string;
+    /** Middleware applied only to this route */
+    middleware?: FNetroMiddleware[];
+    /** Server-side data loader. Return value becomes Page props. */
+    loader?: (c: LoaderCtx) => TData | Promise<TData>;
+    /** Override the group/app layout for this page. Pass `false` to use no layout. */
+    layout?: LayoutDef | false;
+    /** The JSX page component */
+    Page: (props: TData & {
+        url: string;
+        params: Record<string, string>;
+    }) => AnyJSX;
+}
+interface GroupDef {
+    readonly __type: 'group';
+    /** URL prefix — e.g. '/admin' */
+    prefix: string;
+    /** Layout override for all pages in this group */
+    layout?: LayoutDef | false;
+    /** Middleware applied to every route in the group */
+    middleware?: FNetroMiddleware[];
+    /** Pages and nested groups */
+    routes: (PageDef<any> | GroupDef | ApiRouteDef)[];
+}
+interface LayoutDef {
+    readonly __type: 'layout';
+    Component: (props: {
+        children: AnyJSX;
+        url: string;
+        params: Record<string, string>;
+    }) => AnyJSX;
+}
+interface ApiRouteDef {
+    readonly __type: 'api';
+    /** Mount path — e.g. '/api' or '/api/admin' */
+    path: string;
+    /** Register raw Hono routes on the provided sub-app */
+    register: (app: Hono, middleware: FNetroMiddleware[]) => void;
+}
+interface MiddlewareDef {
+    readonly __type: 'middleware';
+    handler: FNetroMiddleware;
+}
+interface AppConfig {
+    /** Default layout for all pages */
+    layout?: LayoutDef;
+    /** Global middleware applied before every route */
+    middleware?: FNetroMiddleware[];
+    /** Top-level routes, groups, and API routes */
+    routes: (PageDef<any> | GroupDef | ApiRouteDef)[];
+    /** 404 page */
+    notFound?: () => AnyJSX;
+}
+declare function definePage<TData extends object = {}>(def: Omit<PageDef<TData>, '__type'>): PageDef<TData>;
+declare function defineGroup(def: Omit<GroupDef, '__type'>): GroupDef;
+declare function defineLayout(Component: LayoutDef['Component']): LayoutDef;
+declare function defineMiddleware(handler: FNetroMiddleware): MiddlewareDef;
+declare function defineApiRoute(path: string, register: ApiRouteDef['register']): ApiRouteDef;
+interface ResolvedRoute {
+    fullPath: string;
+    page: PageDef<any>;
+    layout: LayoutDef | false | undefined;
+    middleware: FNetroMiddleware[];
+}
+declare function resolveRoutes(routes: (PageDef<any> | GroupDef | ApiRouteDef)[], options?: {
+    prefix?: string;
+    middleware?: FNetroMiddleware[];
+    layout?: LayoutDef | false;
+}): {
+    pages: ResolvedRoute[];
+    apis: ApiRouteDef[];
+};
+declare const SPA_HEADER = "x-fnetro-spa";
+declare const STATE_KEY = "__FNETRO_STATE__";
+declare const PARAMS_KEY = "__FNETRO_PARAMS__";
+
+export { type AnyJSX, type ApiRouteDef, type AppConfig, type ComputedRef, type EffectFn, EffectScope, type FNetroMiddleware, type GroupDef, type LayoutDef, type LoaderCtx, type MiddlewareDef, type MultiSource, PARAMS_KEY, type PageDef, ReactiveEffect, type Ref, type ResolvedRoute, SPA_HEADER, STATE_KEY, type WatchEffectOptions, type WatchOptions, type WatchSource, type WritableComputedRef, __hooks, computed, 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 };

package/dist/core.js

@@ -0,0 +1,495 @@
+// 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 };
+}
+function defineGroup(def) {
+  return { __type: "group", ...def };
+}
+function defineLayout(Component) {
+  return { __type: "layout", Component };
+}
+function defineMiddleware(handler) {
+  return { __type: "middleware", handler };
+}
+function defineApiRoute(path, register) {
+  return { __type: "api", path, register };
+}
+function resolveRoutes(routes, options = {}) {
+  const pages = [];
+  const apis = [];
+  for (const route of routes) {
+    if (route.__type === "api") {
+      apis.push({ ...route, path: (options.prefix ?? "") + route.path });
+    } else if (route.__type === "group") {
+      const prefix = (options.prefix ?? "") + route.prefix;
+      const mw = [...options.middleware ?? [], ...route.middleware ?? []];
+      const layout = route.layout !== void 0 ? route.layout : options.layout;
+      const sub = resolveRoutes(route.routes, { prefix, middleware: mw, layout });
+      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 });
+    }
+  }
+  return { pages, apis };
+}
+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);
+}
+export {
+  EffectScope,
+  PARAMS_KEY,
+  ReactiveEffect,
+  SPA_HEADER,
+  STATE_KEY,
+  __hooks,
+  computed,
+  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
+};