npm - @timber-js/app - Versions diffs - 0.1.0 → 0.1.2 - Mend

@timber-js/app 0.1.0 → 0.1.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (141) hide show

package/dist/index.js +5 -2
package/dist/index.js.map +1 -1
package/dist/plugins/entries.d.ts.map +1 -1
package/package.json +43 -58
package/src/adapters/cloudflare.ts +325 -0
package/src/adapters/nitro.ts +366 -0
package/src/adapters/types.ts +63 -0
package/src/cache/index.ts +91 -0
package/src/cache/redis-handler.ts +91 -0
package/src/cache/register-cached-function.ts +99 -0
package/src/cache/singleflight.ts +26 -0
package/src/cache/stable-stringify.ts +21 -0
package/src/cache/timber-cache.ts +116 -0
package/src/cli.ts +201 -0
package/src/client/browser-entry.ts +663 -0
package/src/client/error-boundary.tsx +209 -0
package/src/client/form.tsx +200 -0
package/src/client/head.ts +61 -0
package/src/client/history.ts +46 -0
package/src/client/index.ts +60 -0
package/src/client/link-navigate-interceptor.tsx +62 -0
package/src/client/link-status-provider.tsx +40 -0
package/src/client/link.tsx +310 -0
package/src/client/nuqs-adapter.tsx +117 -0
package/src/client/router-ref.ts +25 -0
package/src/client/router.ts +563 -0
package/src/client/segment-cache.ts +194 -0
package/src/client/segment-context.ts +57 -0
package/src/client/ssr-data.ts +95 -0
package/src/client/types.ts +4 -0
package/src/client/unload-guard.ts +34 -0
package/src/client/use-cookie.ts +122 -0
package/src/client/use-link-status.ts +46 -0
package/src/client/use-navigation-pending.ts +47 -0
package/src/client/use-params.ts +71 -0
package/src/client/use-pathname.ts +43 -0
package/src/client/use-query-states.ts +133 -0
package/src/client/use-router.ts +77 -0
package/src/client/use-search-params.ts +74 -0
package/src/client/use-selected-layout-segment.ts +110 -0
package/src/content/index.ts +13 -0
package/src/cookies/define-cookie.ts +137 -0
package/src/cookies/index.ts +9 -0
package/src/fonts/ast.ts +359 -0
package/src/fonts/css.ts +68 -0
package/src/fonts/fallbacks.ts +248 -0
package/src/fonts/google.ts +332 -0
package/src/fonts/local.ts +177 -0
package/src/fonts/types.ts +88 -0
package/src/index.ts +413 -0
package/src/plugins/adapter-build.ts +118 -0
package/src/plugins/build-manifest.ts +323 -0
package/src/plugins/build-report.ts +353 -0
package/src/plugins/cache-transform.ts +199 -0
package/src/plugins/chunks.ts +90 -0
package/src/plugins/content.ts +136 -0
package/src/plugins/dev-error-overlay.ts +230 -0
package/src/plugins/dev-logs.ts +280 -0
package/src/plugins/dev-server.ts +389 -0
package/src/plugins/dynamic-transform.ts +161 -0
package/src/plugins/entries.ts +207 -0
package/src/plugins/fonts.ts +581 -0
package/src/plugins/mdx.ts +179 -0
package/src/plugins/react-prod.ts +56 -0
package/src/plugins/routing.ts +419 -0
package/src/plugins/server-action-exports.ts +220 -0
package/src/plugins/server-bundle.ts +113 -0
package/src/plugins/shims.ts +168 -0
package/src/plugins/static-build.ts +207 -0
package/src/routing/codegen.ts +396 -0
package/src/routing/index.ts +14 -0
package/src/routing/interception.ts +173 -0
package/src/routing/scanner.ts +487 -0
package/src/routing/status-file-lint.ts +114 -0
package/src/routing/types.ts +100 -0
package/src/search-params/analyze.ts +192 -0
package/src/search-params/codecs.ts +153 -0
package/src/search-params/create.ts +314 -0
package/src/search-params/index.ts +23 -0
package/src/search-params/registry.ts +31 -0
package/src/server/access-gate.tsx +142 -0
package/src/server/action-client.ts +473 -0
package/src/server/action-handler.ts +325 -0
package/src/server/actions.ts +236 -0
package/src/server/asset-headers.ts +81 -0
package/src/server/body-limits.ts +102 -0
package/src/server/build-manifest.ts +234 -0
package/src/server/canonicalize.ts +90 -0
package/src/server/client-module-map.ts +58 -0
package/src/server/csrf.ts +79 -0
package/src/server/deny-renderer.ts +302 -0
package/src/server/dev-logger.ts +419 -0
package/src/server/dev-span-processor.ts +78 -0
package/src/server/dev-warnings.ts +282 -0
package/src/server/early-hints-sender.ts +55 -0
package/src/server/early-hints.ts +142 -0
package/src/server/error-boundary-wrapper.ts +69 -0
package/src/server/error-formatter.ts +184 -0
package/src/server/flush.ts +182 -0
package/src/server/form-data.ts +176 -0
package/src/server/form-flash.ts +93 -0
package/src/server/html-injectors.ts +445 -0
package/src/server/index.ts +222 -0
package/src/server/instrumentation.ts +136 -0
package/src/server/logger.ts +145 -0
package/src/server/manifest-status-resolver.ts +215 -0
package/src/server/metadata-render.ts +527 -0
package/src/server/metadata-routes.ts +189 -0
package/src/server/metadata.ts +263 -0
package/src/server/middleware-runner.ts +32 -0
package/src/server/nuqs-ssr-provider.tsx +63 -0
package/src/server/pipeline.ts +555 -0
package/src/server/prerender.ts +139 -0
package/src/server/primitives.ts +264 -0
package/src/server/proxy.ts +43 -0
package/src/server/request-context.ts +554 -0
package/src/server/route-element-builder.ts +395 -0
package/src/server/route-handler.ts +153 -0
package/src/server/route-matcher.ts +316 -0
package/src/server/rsc-entry/api-handler.ts +112 -0
package/src/server/rsc-entry/error-renderer.ts +177 -0
package/src/server/rsc-entry/helpers.ts +147 -0
package/src/server/rsc-entry/index.ts +688 -0
package/src/server/rsc-entry/ssr-bridge.ts +18 -0
package/src/server/slot-resolver.ts +359 -0
package/src/server/ssr-entry.ts +161 -0
package/src/server/ssr-render.ts +200 -0
package/src/server/status-code-resolver.ts +282 -0
package/src/server/tracing.ts +281 -0
package/src/server/tree-builder.ts +354 -0
package/src/server/types.ts +150 -0
package/src/shims/font-google.ts +67 -0
package/src/shims/headers.ts +11 -0
package/src/shims/image.ts +48 -0
package/src/shims/link.ts +9 -0
package/src/shims/navigation-client.ts +52 -0
package/src/shims/navigation.ts +31 -0
package/src/shims/server-only-noop.js +5 -0
package/src/utils/directive-parser.ts +529 -0
package/src/utils/format.ts +10 -0
package/src/utils/startup-timer.ts +102 -0

package/src/server/ssr-render.ts ADDED Viewed

@@ -0,0 +1,200 @@
+/**
+ * SSR rendering utilities — testable core of the SSR entry.
+ *
+ * Extracted from ssr-entry.ts so the rendering logic can be tested
+ * independently of the Vite RSC plugin runtime (which provides
+ * createFromReadableStream for decoding RSC streams).
+ *
+ * Design docs: 02-rendering-pipeline.md §"Single-Pass Rendering",
+ *              18-build-system.md §"Entry Files"
+ */
+import type { ReactNode } from 'react';
+import { renderToReadableStream } from 'react-dom/server';
+import { formatSsrError } from './error-formatter.js';
+/**
+ * Inline script that injects <meta name="robots" content="noindex"> into <head>.
+ *
+ * Used when a post-flush error (deny() or throw inside Suspense after the shell
+ * has been flushed) is detected. Since <head> has already been sent to the client,
+ * we use a script to dynamically add the meta tag. This signals search engines
+ * not to index the page, mitigating the SEO impact of a 200 status code on what
+ * is effectively an error/deny page.
+ *
+ * See design/05-streaming.md §"deny() inside Suspense"
+ */
+const NOINDEX_SCRIPT =
+  '<script>document.head.appendChild(Object.assign(document.createElement("meta"),{name:"robots",content:"noindex"}))</script>';
+/**
+ * Render a React element tree to a ReadableStream of HTML.
+ *
+ * Uses renderToReadableStream (NOT renderToString) for streaming SSR.
+ * The returned stream begins yielding after onShellReady — everything
+ * outside <Suspense> boundaries is in the shell.
+ *
+ * With progressive streaming, the RSC stream is piped directly to SSR
+ * without buffering. If deny() was called outside a Suspense boundary,
+ * the RSC stream encodes an error in the shell — renderToReadableStream
+ * rejects, and the RSC entry catches this to render a deny page with
+ * the correct HTTP status code. If deny() was inside Suspense, the shell
+ * succeeds (200 committed) and the error streams as an error boundary.
+ *
+ * @param element - The React element tree decoded from the RSC stream
+ * @param options - Optional configuration
+ * @param options.bootstrapScriptContent - Inline JS injected by React as a
+ *   non-deferred `<script>` in the shell HTML. Executes immediately during
+ *   parsing — even while Suspense boundaries are still streaming. Used to
+ *   kick off module loading via dynamic `import()` so hydration can start
+ *   before the HTML stream closes.
+ * @returns A ReadableStream of HTML bytes with hydration markers
+ */
+export async function renderSsrStream(
+  element: ReactNode,
+  options?: { bootstrapScriptContent?: string; deferSuspenseFor?: number; signal?: AbortSignal }
+): Promise<ReadableStream<Uint8Array>> {
+  const signal = options?.signal;
+  const stream = await renderToReadableStream(element, {
+    bootstrapScriptContent: options?.bootstrapScriptContent || undefined,
+    signal,
+    onError(error: unknown) {
+      // Suppress logging for connection aborts — the user refreshed or
+      // navigated away, not an application error.
+      if (isAbortError(error) || signal?.aborted) return;
+      console.error('[timber] SSR render error:', formatSsrError(error));
+    },
+  });
+  // Prevent unhandled promise rejection from streaming-phase errors.
+  // React DOM Server exposes `allReady` — a promise that resolves when
+  // ALL content (including Suspense boundaries) has been rendered. If a
+  // streaming-phase error occurs (e.g. React boundary flush failure),
+  // `allReady` rejects independently of the stream. Without this catch,
+  // the rejection becomes an unhandled promise rejection that crashes
+  // the Node.js process.
+  stream.allReady.catch(() => {});
+  // deferSuspenseFor hold: delay the first read so React can resolve
+  // fast-completing Suspense boundaries before we read the shell HTML.
+  // renderToReadableStream generates HTML lazily on pull — if we wait
+  // before reading, React resolves pending boundaries and inlines their
+  // content instead of serializing fallbacks. Race allReady against
+  // deferSuspenseFor so we don't wait longer than necessary.
+  // See design/05-streaming.md §"deferSuspenseFor"
+  const deferMs = options?.deferSuspenseFor;
+  if (deferMs && deferMs > 0) {
+    await Promise.race([
+      stream.allReady,
+      new Promise<void>((resolve) => setTimeout(resolve, deferMs)),
+    ]);
+  }
+  // renderToReadableStream resolves after onShellReady by default.
+  // The stream is ready to read — the shell (everything outside
+  // Suspense boundaries) is available. Suspense content streams
+  // into the open connection as it resolves.
+  //
+  // Wrap the stream in an error-resilient transform. With progressive
+  // streaming, errors inside Suspense boundaries (e.g. deny() or throws
+  // in async components) cause React's stream to error during the flush
+  // phase. The onError callback logs the error, but the stream error
+  // would become an unhandled promise rejection and crash the process.
+  // The transform catches these post-shell streaming errors and closes
+  // the stream cleanly — the shell (with correct status code) has
+  // already been sent.
+  return wrapStreamWithErrorHandling(stream, signal);
+}
+/**
+ * Wrap an HTML stream with error handling for the streaming phase.
+ *
+ * During progressive RSC→SSR streaming, errors in Suspense boundaries
+ * (e.g. deny() inside Suspense, throws in async components) cause
+ * React DOM's renderToReadableStream to error after the shell has been
+ * flushed. Without this wrapper, the stream error becomes an unhandled
+ * promise rejection that crashes the process.
+ *
+ * The wrapper catches streaming-phase errors, logs them, and closes
+ * the output stream cleanly. The shell (headers, status code, content
+ * outside Suspense) has already been sent to the client.
+ */
+/** @internal Exported for testing only. */
+export function wrapStreamWithErrorHandling(
+  stream: ReadableStream<Uint8Array>,
+  signal?: AbortSignal
+): ReadableStream<Uint8Array> {
+  const reader = stream.getReader();
+  const encoder = new TextEncoder();
+  return new ReadableStream<Uint8Array>({
+    async pull(controller) {
+      try {
+        const { done, value } = await reader.read();
+        if (done) {
+          controller.close();
+          return;
+        }
+        controller.enqueue(value);
+      } catch (error) {
+        // Connection abort (user refreshed or navigated away) — close
+        // silently without logging. This is not an application error.
+        if (isAbortError(error) || signal?.aborted) {
+          controller.close();
+          return;
+        }
+        // Streaming-phase error (e.g. React boundary flush failure,
+        // deny() or throw inside Suspense after flush).
+        // The shell has already been sent with status 200. Inject a
+        // noindex meta tag so search engines don't index this error page,
+        // then close cleanly. See design/05-streaming.md.
+        console.error('[timber] SSR streaming error (post-shell):', formatSsrError(error));
+        controller.enqueue(encoder.encode(NOINDEX_SCRIPT));
+        controller.close();
+      }
+    },
+    cancel() {
+      reader.cancel().catch(() => {});
+    },
+  });
+}
+/**
+ * Check if an error is an abort error (connection closed by client).
+ *
+ * When the browser aborts a request (page refresh, navigation away),
+ * the AbortSignal fires and React/streams throw an AbortError. This
+ * is not an application error — suppress it from error boundaries and logs.
+ */
+function isAbortError(error: unknown): boolean {
+  if (error instanceof DOMException && error.name === 'AbortError') return true;
+  if (error instanceof Error && error.name === 'AbortError') return true;
+  return false;
+}
+/**
+ * Build a Response from the SSR HTML stream with the correct
+ * status code and headers from the navigation context.
+ *
+ * Sets content-type to text/html if not already set by middleware.
+ *
+ * @param htmlStream - The HTML stream from renderSsrStream
+ * @param statusCode - The committed HTTP status code from RSC
+ * @param responseHeaders - Response headers from middleware/proxy
+ * @returns A Response ready to send to the client
+ */
+export function buildSsrResponse(
+  htmlStream: ReadableStream<Uint8Array>,
+  statusCode: number,
+  responseHeaders: Headers
+): Response {
+  if (!responseHeaders.has('content-type')) {
+    responseHeaders.set('content-type', 'text/html; charset=utf-8');
+  }
+  return new Response(htmlStream, {
+    status: statusCode,
+    headers: responseHeaders,
+  });
+}

package/src/server/status-code-resolver.ts ADDED Viewed

@@ -0,0 +1,282 @@
+/**
+ * Status-code file resolver for timber.js error/denial rendering.
+ *
+ * Given an HTTP status code and a matched segment chain, resolves the
+ * correct file to render by walking the fallback chain described in
+ * design/10-error-handling.md §"Status-Code Files".
+ *
+ * Supports two format families:
+ * - 'component' (default): .tsx/.jsx/.mdx status files → React rendering pipeline
+ * - 'json': .json status files → raw JSON response, no React
+ *
+ * Fallback chains operate within the same format family (no cross-format fallback).
+ *
+ * **Component chain (4xx):**
+ *   Pass 1 — status files (leaf → root): {status}.tsx → 4xx.tsx
+ *   Pass 2 — legacy compat (leaf → root): not-found.tsx / forbidden.tsx / unauthorized.tsx
+ *   Pass 3 — error.tsx (leaf → root)
+ *   Pass 4 — framework default (returns null)
+ *
+ * **JSON chain (4xx):**
+ *   Pass 1 — json status files (leaf → root): {status}.json → 4xx.json
+ *   Pass 2 — framework default JSON (returns null, caller provides bare JSON)
+ *
+ * **5xx (component only):**
+ *   Per-segment (leaf → root): {status}.tsx → 5xx.tsx → error.tsx
+ *   Then global-error.tsx (future)
+ *   Then framework default (returns null)
+ */
+import type { SegmentNode, RouteFile } from '#/routing/types.js';
+// ─── Types ───────────────────────────────────────────────────────────────────
+/** How the status-code file was matched. */
+export type StatusFileKind =
+  | 'exact' // e.g. 403.tsx matched status 403
+  | 'category' // e.g. 4xx.tsx matched status 403
+  | 'legacy' // e.g. not-found.tsx matched status 404
+  | 'error'; // error.tsx as last resort
+/** Response format family for status-code resolution. */
+export type StatusFileFormat = 'component' | 'json';
+/** Result of resolving a status-code file for a segment chain. */
+export interface StatusFileResolution {
+  /** The matched route file. */
+  file: RouteFile;
+  /** The HTTP status code (always the original status, not the file's code). */
+  status: number;
+  /** How the file was matched. */
+  kind: StatusFileKind;
+  /** Index into the segments array where the file was found. */
+  segmentIndex: number;
+}
+/** How a slot denial file was matched. */
+export type SlotDeniedKind = 'denied' | 'default';
+/** Result of resolving a slot denied file. */
+export interface SlotDeniedResolution {
+  /** The matched route file (denied.tsx or default.tsx). */
+  file: RouteFile;
+  /** Slot name without @ prefix. */
+  slotName: string;
+  /** How the file was matched. */
+  kind: SlotDeniedKind;
+}
+// ─── Legacy Compat Mapping ───────────────────────────────────────────────────
+/**
+ * Maps legacy file convention names to their corresponding HTTP status codes.
+ * Only used in the 4xx component fallback chain.
+ */
+const LEGACY_FILE_TO_STATUS: Record<string, number> = {
+  'not-found': 404,
+  'forbidden': 403,
+  'unauthorized': 401,
+};
+// ─── Resolver ────────────────────────────────────────────────────────────────
+/**
+ * Resolve the status-code file to render for a given HTTP status code.
+ *
+ * Walks the segment chain from leaf to root following the fallback chain
+ * defined in design/10-error-handling.md. Returns null if no file is found
+ * (caller should render the framework default).
+ *
+ * @param status - The HTTP status code (4xx or 5xx).
+ * @param segments - The matched segment chain from root (index 0) to leaf (last).
+ * @param format - The response format family ('component' or 'json'). Defaults to 'component'.
+ */
+export function resolveStatusFile(
+  status: number,
+  segments: ReadonlyArray<SegmentNode>,
+  format: StatusFileFormat = 'component'
+): StatusFileResolution | null {
+  if (status >= 400 && status <= 499) {
+    return format === 'json' ? resolve4xxJson(status, segments) : resolve4xx(status, segments);
+  }
+  if (status >= 500 && status <= 599) {
+    // JSON format for 5xx uses the same json chain pattern
+    return format === 'json' ? resolve5xxJson(status, segments) : resolve5xx(status, segments);
+  }
+  return null;
+}
+/**
+ * 4xx component fallback chain (three separate passes):
+ *   Pass 1 — status files (leaf → root): {status}.tsx → 4xx.tsx
+ *   Pass 2 — legacy compat (leaf → root): not-found.tsx / forbidden.tsx / unauthorized.tsx
+ *   Pass 3 — error.tsx (leaf → root)
+ */
+function resolve4xx(
+  status: number,
+  segments: ReadonlyArray<SegmentNode>
+): StatusFileResolution | null {
+  const statusStr = String(status);
+  // Pass 1: status files across all segments (leaf → root)
+  for (let i = segments.length - 1; i >= 0; i--) {
+    const segment = segments[i];
+    if (!segment.statusFiles) continue;
+    // Exact match first
+    const exact = segment.statusFiles.get(statusStr);
+    if (exact) {
+      return { file: exact, status, kind: 'exact', segmentIndex: i };
+    }
+    // Category catch-all
+    const category = segment.statusFiles.get('4xx');
+    if (category) {
+      return { file: category, status, kind: 'category', segmentIndex: i };
+    }
+  }
+  // Pass 2: legacy compat files (leaf → root)
+  for (let i = segments.length - 1; i >= 0; i--) {
+    const segment = segments[i];
+    if (!segment.legacyStatusFiles) continue;
+    for (const [name, legacyStatus] of Object.entries(LEGACY_FILE_TO_STATUS)) {
+      if (legacyStatus === status) {
+        const file = segment.legacyStatusFiles.get(name);
+        if (file) {
+          return { file, status, kind: 'legacy', segmentIndex: i };
+        }
+      }
+    }
+  }
+  // Pass 3: error.tsx (leaf → root)
+  for (let i = segments.length - 1; i >= 0; i--) {
+    if (segments[i].error) {
+      return { file: segments[i].error!, status, kind: 'error', segmentIndex: i };
+    }
+  }
+  return null;
+}
+/**
+ * 4xx JSON fallback chain (single pass):
+ *   Pass 1 — json status files (leaf → root): {status}.json → 4xx.json
+ *   No legacy compat, no error.tsx — JSON chain terminates at category catch-all.
+ */
+function resolve4xxJson(
+  status: number,
+  segments: ReadonlyArray<SegmentNode>
+): StatusFileResolution | null {
+  const statusStr = String(status);
+  for (let i = segments.length - 1; i >= 0; i--) {
+    const segment = segments[i];
+    if (!segment.jsonStatusFiles) continue;
+    // Exact match first
+    const exact = segment.jsonStatusFiles.get(statusStr);
+    if (exact) {
+      return { file: exact, status, kind: 'exact', segmentIndex: i };
+    }
+    // Category catch-all
+    const category = segment.jsonStatusFiles.get('4xx');
+    if (category) {
+      return { file: category, status, kind: 'category', segmentIndex: i };
+    }
+  }
+  return null;
+}
+/**
+ * 5xx component fallback chain (single pass, per-segment):
+ *   At each segment (leaf → root): {status}.tsx → 5xx.tsx → error.tsx
+ */
+function resolve5xx(
+  status: number,
+  segments: ReadonlyArray<SegmentNode>
+): StatusFileResolution | null {
+  const statusStr = String(status);
+  for (let i = segments.length - 1; i >= 0; i--) {
+    const segment = segments[i];
+    // Exact status file
+    if (segment.statusFiles) {
+      const exact = segment.statusFiles.get(statusStr);
+      if (exact) {
+        return { file: exact, status, kind: 'exact', segmentIndex: i };
+      }
+      // Category catch-all
+      const category = segment.statusFiles.get('5xx');
+      if (category) {
+        return { file: category, status, kind: 'category', segmentIndex: i };
+      }
+    }
+    // error.tsx at this segment level (for 5xx, checked per-segment)
+    if (segment.error) {
+      return { file: segment.error, status, kind: 'error', segmentIndex: i };
+    }
+  }
+  return null;
+}
+/**
+ * 5xx JSON fallback chain (single pass):
+ *   At each segment (leaf → root): {status}.json → 5xx.json
+ *   No error.tsx equivalent — JSON chain terminates at category catch-all.
+ */
+function resolve5xxJson(
+  status: number,
+  segments: ReadonlyArray<SegmentNode>
+): StatusFileResolution | null {
+  const statusStr = String(status);
+  for (let i = segments.length - 1; i >= 0; i--) {
+    const segment = segments[i];
+    if (!segment.jsonStatusFiles) continue;
+    const exact = segment.jsonStatusFiles.get(statusStr);
+    if (exact) {
+      return { file: exact, status, kind: 'exact', segmentIndex: i };
+    }
+    const category = segment.jsonStatusFiles.get('5xx');
+    if (category) {
+      return { file: category, status, kind: 'category', segmentIndex: i };
+    }
+  }
+  return null;
+}
+// ─── Slot Denied Resolver ────────────────────────────────────────────────────
+/**
+ * Resolve the denial file for a parallel route slot.
+ *
+ * Slot denial is graceful degradation — no HTTP status on the wire.
+ * Fallback chain: denied.tsx → default.tsx → null.
+ *
+ * @param slotNode - The segment node for the slot (segmentType === 'slot').
+ */
+export function resolveSlotDenied(slotNode: SegmentNode): SlotDeniedResolution | null {
+  const slotName = slotNode.segmentName.replace(/^@/, '');
+  if (slotNode.denied) {
+    return { file: slotNode.denied, slotName, kind: 'denied' };
+  }
+  if (slotNode.default) {
+    return { file: slotNode.default, slotName, kind: 'default' };
+  }
+  return null;
+}