setti 0.0.0-stage → 0.1.0-alpha.0

package/dist/index.js

@@ -0,0 +1,816 @@
+import { stringify } from 'devalue';
+export { parse as devalueParse, stringify as devalueStringify } from 'devalue';
+import { createContext, Component, createElement } from 'react';
+
+// src/define-config.ts
+function defineNixoConfig(config) {
+  return config;
+}
+
+// src/define-route.ts
+function defineRoute(routes) {
+  return routes;
+}
+
+// src/define-global-loader.ts
+function defineGlobalLoader(map) {
+  return map;
+}
+
+// src/client/slices/AbstractSlice.ts
+var AbstractSlice = class {
+  /** Текущее состояние. `undefined` до первого hydrate/setState. */
+  _state = void 0;
+  /** База для reset(): первое значение hydrate/setState. */
+  _initialState = void 0;
+  /** Флаг: hydrate уже вызывался. */
+  _hydrated = false;
+  /** Подписчики. */
+  listeners = /* @__PURE__ */ new Set();
+  /**
+   * Инициализация state результатом `loadData`.
+   *
+   * Вызывается Loader'ом один раз на экземпляр. Повторный вызов — ошибка.
+   *
+   * @param result результат `loadData`.
+   * @throws {Error} если hydrate уже вызывался.
+   */
+  hydrate(result) {
+    if (this._hydrated) {
+      throw new Error("Slice: hydrate \u0443\u0436\u0435 \u0432\u044B\u0437\u044B\u0432\u0430\u043B\u0441\u044F. \u0418\u0441\u043F\u043E\u043B\u044C\u0437\u0443\u0439 setState.");
+    }
+    this._hydrated = true;
+    this._state = this._initState(result);
+    if (this._initialState === void 0) {
+      this._initialState = this._state;
+    }
+    this.notify();
+  }
+  /**
+   * Текущее состояние.
+   *
+   * @returns состояние слайса.
+   */
+  getState() {
+    return this._state;
+  }
+  /**
+   * Snapshot для SSR/гидратации (=== getState).
+   *
+   * @returns состояние слайса.
+   */
+  getServerSnapshot() {
+    return this._state;
+  }
+  /**
+   * Обновляет state и уведомляет подписчиков.
+   *
+   * Если `value === prev` (Object.is) — нотификации нет.
+   *
+   * @param next новое значение или функция-апдейтер.
+   */
+  setState(next) {
+    const prev = this._state;
+    const value = typeof next === "function" ? next(prev) : next;
+    if (Object.is(value, prev)) return;
+    this._state = value;
+    if (this._initialState === void 0) {
+      this._initialState = value;
+    }
+    this.notify();
+  }
+  /**
+   * Подписка на изменения.
+   *
+   * @param listener колбэк.
+   * @returns функция отписки.
+   */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  /** Сброс к состоянию первого hydrate/setState. */
+  reset() {
+    if (this._state === this._initialState) return;
+    this._state = this._initialState;
+    this.notify();
+  }
+  /** Уничтожение: очистка подписчиков. */
+  dispose() {
+    this.listeners.clear();
+  }
+  /** Оповещает подписчиков. */
+  notify() {
+    for (const l of this.listeners) l();
+  }
+};
+
+// src/client/slices/Slice.ts
+var Slice = class extends AbstractSlice {
+  /**
+   * Identity: state = result как есть.
+   *
+   * @param result результат `loadData`.
+   * @returns тот же результат.
+   */
+  _initState(result) {
+    return result;
+  }
+};
+
+// src/errors.ts
+var NixoError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "NixoError";
+  }
+};
+var NixoRpcError = class extends NixoError {
+  /** Оригинальный JSON-RPC error. */
+  rpcError;
+  /**
+   * @param rpcError JSON-RPC error payload.
+   */
+  constructor(rpcError) {
+    const detail = rpcError.detail ? ` (${rpcError.detail})` : "";
+    super(`JSON-RPC error ${rpcError.code}: ${rpcError.message}${detail}`);
+    this.name = "NixoRpcError";
+    this.rpcError = rpcError;
+  }
+  /**
+   * Код ошибки.
+   *
+   * @returns код JSON-RPC.
+   */
+  get code() {
+    return this.rpcError.code;
+  }
+  /**
+   * Дополнительное описание.
+   *
+   * @returns detail или `undefined`.
+   */
+  get detail() {
+    return this.rpcError.detail;
+  }
+  /**
+   * Дополнительные данные.
+   *
+   * @returns data или `undefined`.
+   */
+  get data() {
+    return this.rpcError.data;
+  }
+};
+
+// src/client/slices/SliceRegistry.ts
+var SliceRegistry = class {
+  /** Page-scoped слайсы. */
+  page = /* @__PURE__ */ new Map();
+  /** Global-scoped слайсы. */
+  global = /* @__PURE__ */ new Map();
+  /** Подписчики на изменение конкретного ключа (для useSyncExternalStore). */
+  keyListeners = /* @__PURE__ */ new Map();
+  /**
+   * Ищет слайс по ключу: сначала page, потом global.
+   *
+   * @param key имя слайса.
+   * @returns слайс или undefined.
+   */
+  get(key) {
+    return this.page.get(key) ?? this.global.get(key);
+  }
+  /**
+   * Строгий поиск слайса.
+   *
+   * @param key имя слайса.
+   * @returns слайс.
+   * @throws {NixoError} если слайса нет.
+   */
+  require(key) {
+    const slice = this.get(key);
+    if (!slice) {
+      throw new NixoError(`Slice "${key}" not found in registry`);
+    }
+    return slice;
+  }
+  /**
+   * Подписка на изменение присутствия/инстанса слайса по ключу.
+   *
+   * @param key имя слайса.
+   * @param cb колбэк.
+   * @returns функция отписки.
+   */
+  subscribeKey(key, cb) {
+    let set = this.keyListeners.get(key);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.keyListeners.set(key, set);
+    }
+    set.add(cb);
+    return () => {
+      const s = this.keyListeners.get(key);
+      if (!s) return;
+      s.delete(cb);
+      if (s.size === 0) this.keyListeners.delete(key);
+    };
+  }
+  /**
+   * Регистрирует page-scoped слайс.
+   *
+   * @param key имя слайса.
+   * @param slice экземпляр.
+   */
+  setPage(key, slice) {
+    this.page.set(key, slice);
+    this.notifyKey(key);
+  }
+  /**
+   * Регистрирует global-scoped слайс.
+   *
+   * @param key имя слайса.
+   * @param slice экземпляр.
+   */
+  setGlobal(key, slice) {
+    this.global.set(key, slice);
+    this.notifyKey(key);
+  }
+  /** Dispose всех page-слайсов и очистка карты (навигация). */
+  disposePage() {
+    const keys = [...this.page.keys()];
+    for (const key of keys) {
+      this.page.get(key)?.dispose();
+    }
+    this.page.clear();
+    for (const key of keys) this.notifyKey(key);
+  }
+  /** Dispose всех слайсов (конец запроса / размонтирование). */
+  disposeAll() {
+    this.disposePage();
+    const globalKeys = [...this.global.keys()];
+    for (const key of globalKeys) {
+      this.global.get(key)?.dispose();
+    }
+    this.global.clear();
+    for (const key of globalKeys) this.notifyKey(key);
+  }
+  /**
+   * Уведомляет подписчиков на конкретный ключ.
+   *
+   * @param key имя слайса.
+   */
+  notifyKey(key) {
+    const set = this.keyListeners.get(key);
+    if (set) for (const cb of set) cb();
+  }
+};
+
+// src/url.ts
+function idSegments(route, byId) {
+  const segments = [];
+  let current = route;
+  while (current) {
+    if (!current.index) segments.unshift(current.id);
+    current = current.parentId ? byId.get(current.parentId) : void 0;
+  }
+  return segments;
+}
+function computePath(route, byId) {
+  if (route.path) return route.path;
+  const segments = idSegments(route, byId);
+  if (route.slug) {
+    let ri = 0;
+    for (const s of route.slug) {
+      if (s.startsWith("/regex:")) {
+        segments.push(ri === 0 ? ":slug" : `:slug${ri}`);
+        ri++;
+      } else {
+        segments.push(s);
+      }
+    }
+  }
+  return "/" + segments.join("/");
+}
+
+// src/client/rpc/Remote.ts
+var Remote = class {
+  _remoteOpts;
+  /**
+   * @param opts опции сервиса.
+   */
+  constructor(opts) {
+    this._remoteOpts = opts;
+  }
+  /**
+   * Получить имя метода объекта для CRUD-операции.
+   *
+   * @param op CRUD-операция.
+   * @returns имя метода (`Read`, `List`, ...).
+   */
+  resolveMethod(op) {
+    const binding = this._remoteOpts.binding ?? {};
+    return binding[op] ?? DEFAULT_BINDING[op];
+  }
+  /**
+   * Заглушка; полная реализация в R5.
+   *
+   * @param _method имя метода объекта.
+   * @param _params параметры вызова.
+   * @returns `Response`.
+   */
+  async _call(_method, _params) {
+    throw new Error("Remote: not implemented yet (Phase R5)");
+  }
+  // Поля-заглушки, чтобы `T` не был unused.
+  _phantom;
+};
+var DEFAULT_BINDING = {
+  read: "Read",
+  query: "List",
+  create: "Create",
+  update: "Update",
+  destroy: "Delete"
+};
+
+// src/client/rpc/server-bridge.ts
+function isServer() {
+  return typeof window === "undefined";
+}
+function getCurrentHeaders() {
+  if (!isServer()) return {};
+  const getCtx = globalThis.__nixoRpcGetContext;
+  return getCtx?.()?.headers ?? {};
+}
+function getServerExecutor() {
+  if (!isServer()) return null;
+  const getCtx = globalThis.__nixoRpcGetContext;
+  return getCtx?.()?.executor ?? null;
+}
+function getServerCache() {
+  if (!isServer()) return null;
+  const getCtx = globalThis.__nixoRpcGetContext;
+  return getCtx?.()?.cache ?? null;
+}
+var clientServiceCache = /* @__PURE__ */ new Map();
+var Service = class extends Remote {
+  _serviceOpts;
+  /**
+   * @param opts опции.
+   */
+  constructor(opts = {}) {
+    super(opts);
+    this._serviceOpts = opts;
+  }
+  /**
+   * Ключ кэша: `endpoint.method:devalueStringify(params)`.
+   *
+   * @param method метод.
+   * @param params параметры.
+   * @returns ключ.
+   */
+  getCacheKey(method, params) {
+    const endpoint = this._serviceOpts.endpoint ?? "";
+    return `${endpoint}.${method}:${stringify(params ?? {})}`;
+  }
+  /**
+   * Хранилище кэша: ALS (SSR) или модульный `Map` (клиент).
+   *
+   * @returns `Map` или `null`.
+   */
+  getCacheStore() {
+    if (isServer()) return getServerCache();
+    return clientServiceCache;
+  }
+  /**
+   * Низкоуровневый JSON-RPC вызов (без кэша).
+   *
+   * @param method имя метода.
+   * @param params параметры.
+   * @returns `Response`.
+   */
+  async callRaw(method, params) {
+    const fullMethod = this._serviceOpts.endpoint ? `${this._serviceOpts.endpoint}.${method}` : method;
+    const payload = JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      method: fullMethod,
+      params: params ?? {}
+    });
+    return this.executeRequest(payload);
+  }
+  /**
+   * JSON-RPC вызов с кэшем.
+   *
+   * @param method имя метода.
+   * @param params параметры.
+   * @param opts per-call опции (`{ cache }`).
+   * @returns `result`.
+   * @throws {NixoRpcError} при `error` в ответе.
+   */
+  async call(method, params, opts) {
+    const cacheTtl = opts?.cache !== void 0 ? opts.cache : this._serviceOpts.cache;
+    const useCache = typeof cacheTtl === "number" && cacheTtl > 0;
+    const store = useCache ? this.getCacheStore() : null;
+    const cacheKey = useCache ? this.getCacheKey(method, params) : "";
+    if (store && cacheKey) {
+      const cached = store.get(cacheKey);
+      if (cached && cached.expiresAt > Date.now()) {
+        return cached.value;
+      }
+      if (cached) store.delete(cacheKey);
+    }
+    const res = await this.callRaw(method, params);
+    const data = await res.json();
+    if (data.error) throw new NixoRpcError(data.error);
+    const result = data.result;
+    if (store && cacheKey && typeof cacheTtl === "number") {
+      store.set(cacheKey, {
+        value: result,
+        expiresAt: Date.now() + cacheTtl
+      });
+    }
+    return result;
+  }
+  /**
+   * Инвалидирует кэш.
+   *
+   * - `invalidate()` — всё для текущего `endpoint`.
+   * - `invalidate(method)` — все ключи метода.
+   * - `invalidate(method, params)` — точечно.
+   *
+   * @param method метод.
+   * @param params параметры.
+   */
+  invalidate(method, params) {
+    const store = this.getCacheStore();
+    if (!store) return;
+    const endpoint = this._serviceOpts.endpoint ?? "";
+    if (method === void 0) {
+      const prefix = `${endpoint}.`;
+      for (const key of store.keys()) {
+        if (key.startsWith(prefix)) store.delete(key);
+      }
+      return;
+    }
+    if (params === void 0) {
+      const prefix = `${endpoint}.${method}:`;
+      for (const key of store.keys()) {
+        if (key.startsWith(prefix)) store.delete(key);
+      }
+      return;
+    }
+    store.delete(this.getCacheKey(method, params));
+  }
+  /**
+   * Очищает **всё** клиентский кэш (кросс-инстанс).
+   *
+   * На сервере — no-op (per-request кэш в ALS всё равно уничтожится).
+   */
+  static invalidateAll() {
+    clientServiceCache.clear();
+  }
+  /**
+   * CRUD: query (`List` по дефолту).
+   *
+   * @param params параметры.
+   * @param opts per-call опции.
+   * @returns `result`.
+   */
+  async query(params, opts) {
+    return this.call(this.resolveMethod("query"), params, opts);
+  }
+  /**
+   * CRUD: read (`Read` по дефолту).
+   *
+   * @param params параметры.
+   * @param opts per-call опции.
+   * @returns `result`.
+   */
+  async read(params, opts) {
+    return this.call(this.resolveMethod("read"), params, opts);
+  }
+  /**
+   * CRUD: create (`Create` по дефолту).
+   *
+   * @param params параметры.
+   * @param opts per-call опции.
+   * @returns `result`.
+   */
+  async create(params, opts) {
+    return this.call(this.resolveMethod("create"), params, opts);
+  }
+  /**
+   * CRUD: update (`Update` по дефолту).
+   *
+   * @param params параметры.
+   * @param opts per-call опции.
+   * @returns `result`.
+   */
+  async update(params, opts) {
+    return this.call(this.resolveMethod("update"), params, opts);
+  }
+  /**
+   * CRUD: destroy (`Delete` по дефолту).
+   *
+   * @param params параметры.
+   * @param opts per-call опции.
+   * @returns `result`.
+   */
+  async destroy(params, opts) {
+    return this.call(this.resolveMethod("destroy"), params, opts);
+  }
+  /**
+   * URL endpoint.
+   *
+   * @returns URL.
+   */
+  getUrl() {
+    return this._serviceOpts.url ?? "/service";
+  }
+  /**
+   * Заголовки (на сервере — из ALS).
+   *
+   * @returns headers.
+   */
+  prepareHeaders() {
+    const base = { "content-type": "application/json" };
+    if (isServer()) {
+      Object.assign(base, getCurrentHeaders());
+    }
+    return base;
+  }
+  /**
+   * Изоморфный execute:
+   *   - SSR + executor → прямой вызов (без HTTP);
+   *   - иначе → fetch.
+   *
+   * @param payload JSON-RPC payload.
+   * @returns `Response`.
+   */
+  async executeRequest(payload) {
+    if (isServer()) {
+      const executor = getServerExecutor();
+      if (executor) return executor(payload, this.prepareHeaders());
+    }
+    return fetch(this.getUrl(), {
+      method: "POST",
+      headers: this.prepareHeaders(),
+      body: payload,
+      credentials: "same-origin"
+    });
+  }
+};
+
+// src/shared/prefetch.ts
+async function runGlobalPrefetch(ctx, opts = {}) {
+  const { route, globalRegistry, loadModule, registry, router } = ctx;
+  const states = /* @__PURE__ */ new Map();
+  const slices = /* @__PURE__ */ new Map();
+  const needed = new Set(
+    route.contentConfig.prefetchConfig.dependencies ?? []
+  );
+  const queue = [...needed];
+  while (queue.length > 0) {
+    const name = queue.shift();
+    const def = globalRegistry[name];
+    if (!def) continue;
+    for (const dep of def.dependencies ?? []) {
+      if (!needed.has(dep)) {
+        needed.add(dep);
+        queue.push(dep);
+      }
+    }
+  }
+  if (opts.skipExisting) {
+    for (const name of [...needed]) {
+      if (registry.get(name)) needed.delete(name);
+    }
+  }
+  if (needed.size === 0) return states;
+  const sorted = topoSort(needed, (name) => {
+    const def = globalRegistry[name];
+    if (!def) {
+      throw new NixoError(
+        `Global dependency "${name}" not found in any *.loader.ts`
+      );
+    }
+    return def.dependencies ?? [];
+  });
+  for (const name of sorted) {
+    const def = globalRegistry[name];
+    const implRaw = await loadModule(def.dataFactoryName);
+    const impl = implRaw;
+    if (!impl || typeof impl.loadData !== "function" || typeof impl.slice !== "function") {
+      throw new NixoError(
+        `Invalid global loader "${name}": expected loadData + slice class`
+      );
+    }
+    const args = { ...def.dataFactoryArguments ?? {} };
+    if (typeof impl.getDataFactoryArguments === "function") {
+      Object.assign(args, await impl.getDataFactoryArguments());
+    }
+    const deps = {};
+    for (const dep of def.dependencies ?? []) deps[dep] = states.get(dep);
+    const data = await impl.loadData(args, deps, { router });
+    states.set(name, data);
+    slices.set(name, {
+      dataFactoryName: def.dataFactoryName,
+      state: data,
+      scope: "global"
+    });
+    const SliceClass = impl.slice;
+    const slice = new SliceClass();
+    slice.hydrate(data);
+    registry.setGlobal(name, slice);
+  }
+  return states;
+}
+async function runPagePrefetch(ctx, globalStates) {
+  const { route, globalRegistry, loadModule, registry, router } = ctx;
+  const prefetchCfg = route.contentConfig.prefetchConfig;
+  const states = new Map(globalStates);
+  const slices = /* @__PURE__ */ new Map();
+  const getConfigRaw = await loadModule(prefetchCfg.configLoader);
+  if (typeof getConfigRaw !== "function") {
+    throw new NixoError(
+      `configLoader "${prefetchCfg.configLoader}" must export a function`
+    );
+  }
+  const factoryMap = await getConfigRaw(
+    prefetchCfg.configParams ?? {},
+    router
+  );
+  if (!factoryMap || typeof factoryMap !== "object") {
+    throw new NixoError(
+      `getConfig from "${prefetchCfg.configLoader}" must return an object`
+    );
+  }
+  for (const name of Object.keys(factoryMap)) {
+    if (globalRegistry[name]) {
+      throw new NixoError(
+        `A3 violation: "${name}" declared both in page's getConfig and global registry`
+      );
+    }
+  }
+  const needed = new Set(Object.keys(factoryMap));
+  const queue = [...needed];
+  while (queue.length > 0) {
+    const name = queue.shift();
+    const def = factoryMap[name];
+    if (!def) continue;
+    for (const dep of def.dependencies ?? []) {
+      if (!needed.has(dep) && !globalStates.has(dep)) {
+        needed.add(dep);
+        queue.push(dep);
+      }
+    }
+  }
+  const sorted = topoSort(needed, (name) => {
+    const def = factoryMap[name];
+    if (!def) {
+      if (globalStates.has(name)) return [];
+      throw new NixoError(
+        `Unknown dependency "${name}" \u2014 not in getConfig, not a loaded global`
+      );
+    }
+    return def.dependencies ?? [];
+  });
+  for (const name of sorted) {
+    const def = factoryMap[name];
+    const implRaw = await loadModule(def.dataFactoryName);
+    const impl = implRaw;
+    if (!impl || typeof impl.loadData !== "function" || typeof impl.slice !== "function") {
+      throw new NixoError(`Invalid factory "${name}": expected loadData + slice`);
+    }
+    const args = { ...def.dataFactoryArguments ?? {} };
+    if (typeof impl.getDataFactoryArguments === "function") {
+      Object.assign(args, await impl.getDataFactoryArguments());
+    }
+    const deps = {};
+    for (const dep of def.dependencies ?? []) deps[dep] = states.get(dep);
+    const data = await impl.loadData(args, deps, { router });
+    states.set(name, data);
+    slices.set(name, {
+      dataFactoryName: def.dataFactoryName,
+      state: data,
+      scope: "page"
+    });
+    const SliceClass = impl.slice;
+    const slice = new SliceClass();
+    slice.hydrate(data);
+    registry.setPage(name, slice);
+  }
+  for (const [name, data] of globalStates) {
+    const def = globalRegistry[name];
+    if (def) {
+      slices.set(name, {
+        dataFactoryName: def.dataFactoryName,
+        state: data,
+        scope: "global"
+      });
+    }
+  }
+  return { states, slices };
+}
+async function runPrefetch(ctx) {
+  const globalStates = await runGlobalPrefetch(ctx);
+  return runPagePrefetch(ctx, globalStates);
+}
+function topoSort(nodes, depsOf) {
+  const result = [];
+  const state = /* @__PURE__ */ new Map();
+  const visit = (name, pathStack) => {
+    const s = state.get(name);
+    if (s === "done") return;
+    if (s === "visiting") {
+      throw new NixoError(
+        `Cycle detected: ${[...pathStack, name].join(" \u2192 ")}`
+      );
+    }
+    state.set(name, "visiting");
+    for (const dep of depsOf(name)) visit(dep, [...pathStack, name]);
+    state.set(name, "done");
+    result.push(name);
+  };
+  for (const name of nodes) visit(name, []);
+  return result;
+}
+createContext(null);
+createContext(null);
+var NixoErrorBoundary = class extends Component {
+  state = { error: null };
+  /**
+   * @param error ошибка из дочернего дерева.
+   * @returns новое состояние.
+   */
+  static getDerivedStateFromError(error) {
+    return { error };
+  }
+  /**
+   * Логирует ошибку.
+   *
+   * @param error ошибка.
+   * @param info React error info.
+   */
+  componentDidCatch(error, info) {
+    console.error("[nixo] error boundary caught:", error, info);
+  }
+  /**
+   * Рендер: fallback при ошибке, иначе `children`.
+   *
+   * @returns ReactNode.
+   */
+  render() {
+    if (this.state.error) {
+      const Fallback = this.props.fallback;
+      if (Fallback) {
+        return createElement(Fallback, { error: this.state.error });
+      }
+      return createElement(
+        "div",
+        {
+          style: {
+            padding: "1rem",
+            color: "crimson",
+            fontFamily: "system-ui, sans-serif"
+          }
+        },
+        "Error: " + this.state.error.message
+      );
+    }
+    return this.props.children;
+  }
+};
+function NixoLoading() {
+  return createElement(
+    "div",
+    {
+      style: {
+        padding: "1rem",
+        color: "#666",
+        fontFamily: "system-ui, sans-serif"
+      }
+    },
+    "Loading\u2026"
+  );
+}
+function NixoNotFound() {
+  return createElement(
+    "div",
+    {
+      style: {
+        padding: "3rem 1rem",
+        textAlign: "center",
+        fontFamily: "system-ui, sans-serif"
+      }
+    },
+    createElement("h1", { style: { fontSize: "3rem", margin: 0 } }, "404"),
+    createElement("p", { style: { color: "#666" } }, "Page not found")
+  );
+}
+
+export { AbstractSlice, NixoError, NixoErrorBoundary, NixoLoading, NixoNotFound, NixoRpcError, Service as NixoService, Slice, SliceRegistry, computePath, defineGlobalLoader, defineNixoConfig, defineRoute, runGlobalPrefetch, runPagePrefetch, runPrefetch };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map