@nubbin/next 0.1.0-rc.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jesse Wheeler
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,46 @@
+import { FieldHintData, ArtifactStore, Artifact } from '@nubbin/core';
+
+/**
+ * Maps a hole's declared lifecycle onto Next's fetch cache, so the mapping is owned by the
+ * binding rather than re-decided in every consumer's resolver. `no-store` also makes a page
+ * carrying a request hole dynamic — per-request resolution is exactly what it declared.
+ *
+ * Takes core's `FieldHintData` directly. An earlier plan derived a local `HoleSpec` from
+ * `ArtifactNode["holes"]` so two packages would not import each other; core exports the type
+ * by name, so both import it from core and neither derivation is needed.
+ */
+declare function holeFetchOptions(spec: FieldHintData): RequestInit & {
+    next?: {
+        revalidate: number;
+    };
+};
+
+/**
+ * Pointer first, invalidation second. The reverse order re-caches the outgoing page during
+ * the gap, and the publish appears to have silently not happened. The store's own publish
+ * rejects a hash that was never written, so a failed publish never purges a working page.
+ */
+declare function publishRoute(store: ArtifactStore, route: string, hash: string): Promise<void>;
+
+/**
+ * The whole production read path: one pointer read, one artifact read. Null means the caller
+ * renders a real 404 — an unpublished route has no pointer, which is what makes unpublish a
+ * server 404 rather than an empty page.
+ */
+declare function resolveArtifact(store: ArtifactStore, slug: readonly string[] | undefined): Promise<Artifact | null>;
+
+/** Catch-all params to the route string artifacts and pointers are keyed by. */
+declare function routeFromSlug(slug: readonly string[] | undefined): string;
+
+/**
+ * generateStaticParams source. manifest() is an advisory read for exactly this — no request
+ * ever goes through it. Non-exact pointers are excluded until #5 settles pattern routing.
+ */
+declare function staticRouteParams(store: ArtifactStore): Promise<{
+    slug: string[];
+}[]>;
+
+/** Pointer removed, then that one route invalidated — the next request renders a real 404. */
+declare function unpublishRoute(store: ArtifactStore, route: string): Promise<void>;
+
+export { holeFetchOptions, publishRoute, resolveArtifact, routeFromSlug, staticRouteParams, unpublishRoute };

package/dist/index.js

@@ -0,0 +1,52 @@
+// src/holeFetchOptions.ts
+function holeFetchOptions(spec) {
+  if (spec === "request") {
+    return { cache: "no-store" };
+  }
+  return { next: { revalidate: spec.revalidate } };
+}
+
+// src/publishRoute.ts
+import { revalidatePath } from "next/cache";
+async function publishRoute(store, route, hash) {
+  await store.publish(route, hash);
+  revalidatePath(route);
+}
+
+// src/routeFromSlug.ts
+function routeFromSlug(slug) {
+  if (!slug || slug.length === 0) {
+    return "/";
+  }
+  return `/${slug.join("/")}`;
+}
+
+// src/resolveArtifact.ts
+async function resolveArtifact(store, slug) {
+  const pointer = await store.pointer(routeFromSlug(slug));
+  if (!pointer) {
+    return null;
+  }
+  return store.read(pointer.hash);
+}
+
+// src/staticRouteParams.ts
+async function staticRouteParams(store) {
+  const { routes } = await store.manifest();
+  return routes.filter((pointer) => pointer.matchKind === "exact").map((pointer) => ({ slug: pointer.route.split("/").filter((segment) => segment.length > 0) }));
+}
+
+// src/unpublishRoute.ts
+import { revalidatePath as revalidatePath2 } from "next/cache";
+async function unpublishRoute(store, route) {
+  await store.unpublish(route);
+  revalidatePath2(route);
+}
+export {
+  holeFetchOptions,
+  publishRoute,
+  resolveArtifact,
+  routeFromSlug,
+  staticRouteParams,
+  unpublishRoute
+};

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@nubbin/next",
+  "version": "0.1.0-rc.0",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@nubbin/core": "0.1.0-rc.0"
+  },
+  "peerDependencies": {
+    "next": ">=16.0.0"
+  },
+  "devDependencies": {
+    "next": "16.2.7",
+    "tsup": "8.5.1",
+    "typescript": "6.0.3",
+    "vitest": "4.1.10"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  }
+}