@rsc-kit/core 0.8.0 → 0.9.0

package/dist/metadata.d.ts

@@ -0,0 +1,69 @@
+export interface IconDescriptor {
+    url: string | URL;
+    type?: string;
+    sizes?: string;
+    color?: string;
+    rel?: string;
+    media?: string;
+    fetchPriority?: 'high' | 'low' | 'auto';
+}
+export type IconURL = string | URL;
+export interface Icons {
+    icon?: IconURL | IconDescriptor | (IconURL | IconDescriptor)[];
+    apple?: IconURL | IconDescriptor | (IconURL | IconDescriptor)[];
+    shortcut?: IconURL | IconDescriptor | (IconURL | IconDescriptor)[];
+    other?: IconDescriptor | IconDescriptor[];
+}
+/** A layout's title, wrapping the titles of the pages beneath it. */
+export interface TitleTemplate {
+    /** `%s` stands in for the page's own title. */
+    template?: string;
+    /** Used by a page that exports no title of its own. */
+    default?: string;
+}
+export interface Metadata {
+    /** A string on a page; a template on a layout, applied to the pages below it. */
+    title?: string | TitleTemplate;
+    description?: string;
+    keywords?: string | string[];
+    author?: string;
+    robots?: string;
+    icons?: IconURL | (IconURL | IconDescriptor)[] | Icons | null;
+    'og:title'?: string;
+    'og:description'?: string;
+    'og:image'?: string;
+    'og:url'?: string;
+    'og:type'?: string;
+    'og:site_name'?: string;
+    'twitter:card'?: string;
+    'twitter:title'?: string;
+    'twitter:description'?: string;
+    'twitter:image'?: string;
+    'twitter:site'?: string;
+    /**
+     * Any other meta tag, by name.
+     *
+     *     other: { 'fb:app_id': '123', 'theme-color': '#000' }
+     *
+     * Here rather than alongside the named keys, and that is what makes the rest
+     * of this interface worth annotating. An index signature on the interface
+     * itself made every key legal — so `titel` was accepted in silence, and an
+     * editor offered no completions at all, because with any identifier valid
+     * TypeScript reads an unfinished key as a shorthand property and goes looking
+     * for a variable by that name.
+     */
+    other?: Record<string, string | string[] | null | undefined>;
+}
+/**
+ * Metadata that depends on the request.
+ *
+ * Receives the same awaitables a page does, so one shape is learned rather
+ * than two:
+ *
+ *     export const generateMetadata: GenerateMetadata<{ slug: string }> =
+ *       async ({ params }) => ({ title: (await params).slug })
+ */
+export type GenerateMetadata<P = Record<string, string>> = (args: {
+    params: Promise<P>;
+    searchParams: Promise<URLSearchParams>;
+}) => Metadata | Promise<Metadata>;

package/dist/metadata.js

@@ -0,0 +1,17 @@
+// What a page says about itself, as importable types.
+//
+//     import type { Metadata } from '@rsc-kit/core/metadata'
+//
+//     export const metadata: Metadata = { title: 'Orders' }
+//
+// Imported rather than ambient, and that is the whole point of the move. An
+// ambient declaration has to be COPIED into the project, which means it is not
+// there until the build has run once — so a freshly cloned app reports "Cannot
+// find name 'Metadata'" on every page until someone runs the dev server. An
+// import resolves from node_modules the moment dependencies are installed.
+//
+// The ambient names still work. `.rsc-kit/rsc-types.d.ts` now aliases these
+// rather than restating them, so there is one definition and two ways to reach
+// it.
+export {};
+//# sourceMappingURL=metadata.js.map

package/dist/metadata.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.js","sourceRoot":"","sources":["../src/metadata.ts"],"names":[],"mappings":"AAAA,sDAAsD;AACtD,EAAE;AACF,6DAA6D;AAC7D,EAAE;AACF,4DAA4D;AAC5D,EAAE;AACF,4EAA4E;AAC5E,+EAA+E;AAC/E,+EAA+E;AAC/E,4EAA4E;AAC5E,2EAA2E;AAC3E,EAAE;AACF,4EAA4E;AAC5E,+EAA+E;AAC/E,MAAM","sourcesContent":["// What a page says about itself, as importable types.\n//\n//     import type { Metadata } from '@rsc-kit/core/metadata'\n//\n//     export const metadata: Metadata = { title: 'Orders' }\n//\n// Imported rather than ambient, and that is the whole point of the move. An\n// ambient declaration has to be COPIED into the project, which means it is not\n// there until the build has run once — so a freshly cloned app reports \"Cannot\n// find name 'Metadata'\" on every page until someone runs the dev server. An\n// import resolves from node_modules the moment dependencies are installed.\n//\n// The ambient names still work. `.rsc-kit/rsc-types.d.ts` now aliases these\n// rather than restating them, so there is one definition and two ways to reach\n// it.\n\nexport interface IconDescriptor {\n  url: string | URL\n  type?: string\n  sizes?: string\n  color?: string\n  rel?: string\n  media?: string\n  fetchPriority?: 'high' | 'low' | 'auto'\n}\n\nexport type IconURL = string | URL\n\nexport interface Icons {\n  icon?: IconURL | IconDescriptor | (IconURL | IconDescriptor)[]\n  apple?: IconURL | IconDescriptor | (IconURL | IconDescriptor)[]\n  shortcut?: IconURL | IconDescriptor | (IconURL | IconDescriptor)[]\n  other?: IconDescriptor | IconDescriptor[]\n}\n\n/** A layout's title, wrapping the titles of the pages beneath it. */\nexport interface TitleTemplate {\n  /** `%s` stands in for the page's own title. */\n  template?: string\n  /** Used by a page that exports no title of its own. */\n  default?: string\n}\n\nexport interface Metadata {\n  /** A string on a page; a template on a layout, applied to the pages below it. */\n  title?: string | TitleTemplate\n  description?: string\n  keywords?: string | string[]\n  author?: string\n  robots?: string\n  icons?: IconURL | (IconURL | IconDescriptor)[] | Icons | null\n  'og:title'?: string\n  'og:description'?: string\n  'og:image'?: string\n  'og:url'?: string\n  'og:type'?: string\n  'og:site_name'?: string\n  'twitter:card'?: string\n  'twitter:title'?: string\n  'twitter:description'?: string\n  'twitter:image'?: string\n  'twitter:site'?: string\n\n  /**\n   * Any other meta tag, by name.\n   *\n   *     other: { 'fb:app_id': '123', 'theme-color': '#000' }\n   *\n   * Here rather than alongside the named keys, and that is what makes the rest\n   * of this interface worth annotating. An index signature on the interface\n   * itself made every key legal — so `titel` was accepted in silence, and an\n   * editor offered no completions at all, because with any identifier valid\n   * TypeScript reads an unfinished key as a shorthand property and goes looking\n   * for a variable by that name.\n   */\n  other?: Record<string, string | string[] | null | undefined>\n}\n\n/**\n * Metadata that depends on the request.\n *\n * Receives the same awaitables a page does, so one shape is learned rather\n * than two:\n *\n *     export const generateMetadata: GenerateMetadata<{ slug: string }> =\n *       async ({ params }) => ({ title: (await params).slug })\n */\nexport type GenerateMetadata<P = Record<string, string>> = (args: {\n  params: Promise<P>\n  searchParams: Promise<URLSearchParams>\n}) => Metadata | Promise<Metadata>\n"]}

package/dist/vite.js

@@ -413,10 +413,19 @@ function warnIfTypesUnreachable() {
         const include = JSON.parse(text).include;
         if (!Array.isArray(include))
             return;
-        if (include.some((entry) => typeof entry === 'string' && entry.includes('.rsc-kit')))
-            return;
-        log(`tsconfig.json does not include .rsc-kit, where the generated types are written.\n` +
-            `  Add ".rsc-kit/**/*" to "include", or typed routes and rpc() fall back to string.`);
+        const covers = (what) => include.some((entry) => typeof entry === 'string' && entry.includes(what));
+        if (!covers('.rsc-kit')) {
+            log(`tsconfig.json does not include .rsc-kit, where the generated types are written.\n` +
+                `  Add ".rsc-kit/**/*" to "include", or typed routes and rpc() fall back to string.`);
+        }
+        // Only when there is something there to check. An app with no api routes
+        // has nothing to be warned about, and a warning it cannot act on is one it
+        // learns to scroll past.
+        if (existsSync(join(projectRoot, 'server')) && !covers('server')) {
+            log(`tsconfig.json does not include server/, where your api handlers live.\n` +
+                `  Add "server/**/*" to "include", or they are not type-checked at all — ` +
+                `a handler returning the wrong shape builds and deploys without complaint.`);
+        }
     }
     catch {
         // An unparseable tsconfig is the project's own problem, not this one's.
@@ -451,10 +460,6 @@ function writeHostBindings(manifest) {
     // and a typecheck cannot see it. Written whether or not there are actions:
     // server components call it directly too.
     writeFileSync(join(typesDir, 'rsc-env.d.ts'), renderHostGlobalTypes());
-    // The engine's own ambient types, copied where the app's typechecker will
-    // see them. Deliberately a separate file from the one above: this one is
-    // the engine's and identical everywhere, that one is generated from how
-    // this host is configured.
     // The urls this build found, so a link to a page that does not exist fails
     // the typecheck instead of the browser.
     writeFileSync(join(typesDir, 'rsc-routes.d.ts'), renderRouteTypes(manifest));
@@ -463,10 +468,6 @@ function writeHostBindings(manifest) {
     // an app-authored one goes stale — the first version named only RscEngine,
     // which typechecks a server and fails a prerender script.
     writeFileSync(join(typesDir, 'rsc-engine.d.ts'), ENGINE_TYPES);
-    const engineTypes = join(packageDir, 'types.d.ts');
-    if (existsSync(engineTypes)) {
-        writeFileSync(join(typesDir, 'rsc-types.d.ts'), readFileSync(engineTypes, 'utf-8'));
-    }
     warnIfTypesUnreachable();
     const target = join(sourceDir, 'server-actions.generated.ts');
     // A host with no functions of its own leaves no file behind: kept, its
@@ -1492,7 +1493,14 @@ async function renderTree(
       if (bootstrap) head.push(createElement(DocumentTitle, { key: '__ts', title: String(md.title) }))
     }
     if (md.description != null) head.push(createElement('meta', { key: '__d', name: 'description', content: String(md.description) }))
-    for (const [k, v] of Object.entries(md)) {
+    // other is flattened in beside the named keys, because it is a place to put
+    // meta tags rather than a meta tag by that name. A key at the top level
+    // still renders — the type no longer invites one, but an app written
+    // against the old shape must not silently lose its tags.
+    const named = Object.entries(md).filter(([k]) => k !== 'other')
+    const extra = Object.entries((md.other ?? {}) as Record<string, unknown>)
+
+    for (const [k, v] of [...named, ...extra]) {
       if (k === 'title' || k === 'description' || v == null) continue
       head.push(createElement('meta', { key: '__m_' + k, name: k, content: String(v) }))
     }
@@ -2017,12 +2025,31 @@ export async function resolveMetadata(
     : {}
 
   // Non-title metadata: layout defaults (outer→inner), page overrides.
+  //
+  // other merges per key rather than being replaced, so a page adding one
+  // custom tag keeps the ones its layout set. Assigning it like any other key
+  // would mean a root layout's theme-color disappearing from every page that
+  // happened to declare one of its own.
   const merged: Record<string, unknown> = {}
+  const other: Record<string, unknown> = {}
+
+  const take = (from: Record<string, unknown>) => {
+    for (const [k, v] of Object.entries(from)) {
+      if (k === 'title') continue
+      if (k === 'other') Object.assign(other, v as Record<string, unknown>)
+      else merged[k] = v
+    }
+  }
+
   for (const l of layouts) {
     const s = metadataMap[l.component]?.static
-    if (s) for (const [k, v] of Object.entries(s)) if (k !== 'title') merged[k] = v
+
+    if (s) take(s as Record<string, unknown>)
   }
-  for (const [k, v] of Object.entries(page)) if (k !== 'title') merged[k] = v
+
+  take(page)
+
+  if (Object.keys(other).length > 0) merged.other = other
 
   // Title: the page title with the NEAREST layout title.template applied; if the
   // page has no title, the nearest layout default/string title.