@janmarkuslanger/astro-strapi-platform 0.0.0-stage → 0.1.0

package/package.json

@@ -1,6 +1,27 @@
 {
   "name": "@janmarkuslanger/astro-strapi-platform",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Astro + Strapi platform: domain model and block contract, Strapi adapter, Astro rendering and consent, Strapi schemas and bootstrap helpers.",
+  "license": "MIT",
+  "type": "module",
+  "keywords": ["astro-component", "strapi"],
+  "exports": {
+    "./core": { "types": "./dist/core/index.d.ts", "import": "./dist/core/index.js" },
+    "./strapi": { "types": "./dist/strapi/index.d.ts", "import": "./dist/strapi/index.js" },
+    "./astro": "./src/astro/index.ts",
+    "./astro/BlockRenderer.astro": "./src/astro/BlockRenderer.astro",
+    "./strapi-kit": { "types": "./dist/strapi-kit/index.d.ts", "default": "./dist/strapi-kit/index.js" },
+    "./strapi-kit/schemas-cli": "./dist/strapi-kit/schemas-cli.js"
+  },
+  "typesVersions": { "*": { "strapi-kit": ["dist/strapi-kit/index.d.ts"] } },
+  "files": ["dist", "src/astro", "schemas"],
+  "scripts": {
+    "build": "tsc -p tsconfig.json && tsc -p tsconfig.strapi-kit.json && node -e \"require('node:fs').copyFileSync('src/strapi-kit/package.json', 'dist/strapi-kit/package.json')\""
+  },
+  "dependencies": { "marked": "^14.1.3" },
+  "peerDependencies": { "astro": "^4.16.0", "@strapi/strapi": "^5.0.0" },
+  "peerDependenciesMeta": { "astro": { "optional": true }, "@strapi/strapi": { "optional": true } },
+  "devDependencies": { "typescript": "^5.6.3" },
+  "publishConfig": { "access": "public" },
+  "repository": { "type": "git", "url": "git+https://github.com/janmarkuslanger/astro-strapi-template.git", "directory": "packages/astro-strapi-platform" }
+}

package/schemas/api/global/content-types/global/schema.json

@@ -0,0 +1,40 @@
+{
+  "kind": "singleType",
+  "collectionName": "globals",
+  "info": {
+    "singularName": "global",
+    "pluralName": "globals",
+    "displayName": "Global settings"
+  },
+  "options": {
+    "draftAndPublish": false
+  },
+  "pluginOptions": {
+    "content-type-builder": {
+      "visible": false
+    }
+  },
+  "attributes": {
+    "siteName": {
+      "type": "string",
+      "required": true
+    },
+    "claim": {
+      "type": "string"
+    },
+    "email": {
+      "type": "email",
+      "required": true
+    },
+    "navigation": {
+      "type": "component",
+      "repeatable": true,
+      "component": "shared.link"
+    },
+    "footerLinks": {
+      "type": "component",
+      "repeatable": true,
+      "component": "shared.link"
+    }
+  }
+}

package/schemas/api/global/controllers/global.ts

@@ -0,0 +1,3 @@
+import { factories } from "@strapi/strapi";
+
+export default factories.createCoreController("api::global.global");

package/schemas/api/global/routes/global.ts

@@ -0,0 +1,3 @@
+import { factories } from "@strapi/strapi";
+
+export default factories.createCoreRouter("api::global.global");

package/schemas/api/global/services/global.ts

@@ -0,0 +1,3 @@
+import { factories } from "@strapi/strapi";
+
+export default factories.createCoreService("api::global.global");

package/schemas/api/page/content-types/page/schema.json

@@ -0,0 +1,39 @@
+{
+  "kind": "collectionType",
+  "collectionName": "pages",
+  "info": {
+    "singularName": "page",
+    "pluralName": "pages",
+    "displayName": "Page"
+  },
+  "options": {
+    "draftAndPublish": true
+  },
+  "pluginOptions": {
+    "content-type-builder": {
+      "visible": false
+    }
+  },
+  "attributes": {
+    "title": {
+      "type": "string",
+      "required": true
+    },
+    "slug": {
+      "type": "uid",
+      "targetField": "title",
+      "required": true
+    },
+    "seo": {
+      "type": "component",
+      "repeatable": false,
+      "component": "shared.seo"
+    },
+    "blocks": {
+      "type": "dynamiczone",
+      "components": [
+        "blocks.reference"
+      ]
+    }
+  }
+}

package/schemas/api/page/controllers/page.ts

@@ -0,0 +1,3 @@
+import { factories } from "@strapi/strapi";
+
+export default factories.createCoreController("api::page.page");

package/schemas/api/page/routes/page.ts

@@ -0,0 +1,3 @@
+import { factories } from "@strapi/strapi";
+
+export default factories.createCoreRouter("api::page.page");

package/schemas/api/page/services/page.ts

@@ -0,0 +1,3 @@
+import { factories } from "@strapi/strapi";
+
+export default factories.createCoreService("api::page.page");

package/schemas/api/shared-block/content-types/shared-block/schema.json

@@ -0,0 +1,28 @@
+{
+  "kind": "collectionType",
+  "collectionName": "shared_blocks",
+  "info": {
+    "singularName": "shared-block",
+    "pluralName": "shared-blocks",
+    "displayName": "Reusable block"
+  },
+  "options": {
+    "draftAndPublish": true
+  },
+  "pluginOptions": {
+    "content-type-builder": {
+      "visible": false
+    }
+  },
+  "attributes": {
+    "name": {
+      "type": "string",
+      "required": true,
+      "unique": true
+    },
+    "blocks": {
+      "type": "dynamiczone",
+      "components": []
+    }
+  }
+}

package/schemas/api/shared-block/controllers/shared-block.ts

@@ -0,0 +1,3 @@
+import { factories } from "@strapi/strapi";
+
+export default factories.createCoreController("api::shared-block.shared-block");

package/schemas/api/shared-block/routes/shared-block.ts

@@ -0,0 +1,3 @@
+import { factories } from "@strapi/strapi";
+
+export default factories.createCoreRouter("api::shared-block.shared-block");

package/schemas/api/shared-block/services/shared-block.ts

@@ -0,0 +1,3 @@
+import { factories } from "@strapi/strapi";
+
+export default factories.createCoreService("api::shared-block.shared-block");

package/schemas/components/blocks/reference.json

@@ -0,0 +1,15 @@
+{
+  "collectionName": "components_blocks_references",
+  "info": {
+    "displayName": "Reference",
+    "icon": "link"
+  },
+  "options": {},
+  "attributes": {
+    "block": {
+      "type": "relation",
+      "relation": "oneToOne",
+      "target": "api::shared-block.shared-block"
+    }
+  }
+}

package/schemas/components/shared/link.json

@@ -0,0 +1,9 @@
+{
+  "collectionName": "components_shared_links",
+  "info": { "displayName": "Link", "icon": "link" },
+  "options": {},
+  "attributes": {
+    "label": { "type": "string", "required": true },
+    "href": { "type": "string", "required": true }
+  }
+}

package/schemas/components/shared/seo.json

@@ -0,0 +1,9 @@
+{
+  "collectionName": "components_shared_seos",
+  "info": { "displayName": "SEO", "icon": "search" },
+  "options": {},
+  "attributes": {
+    "title": { "type": "string" },
+    "description": { "type": "text", "maxLength": 200 }
+  }
+}

package/src/astro/BlockRenderer.astro

@@ -0,0 +1,29 @@
+---
+/**
+ * Renders domain blocks through the site's block registry. Names no block
+ * type.
+ *
+ * A block without a definition renders NOTHING rather than throwing: an
+ * unknown block must never take a page down. Together with the adapter (which
+ * already skips unknown CMS components), a block added in the CMS ahead of
+ * the frontend is harmless.
+ */
+import {
+  definitionFor,
+  type BaseBlock,
+  type BlockRegistry,
+} from "@janmarkuslanger/astro-strapi-platform/core";
+
+interface Props<B extends BaseBlock> {
+  blocks: B[];
+  registry: BlockRegistry<B>;
+}
+const { blocks, registry } = Astro.props;
+---
+
+{
+  blocks.map((block) => {
+    const Component = definitionFor(registry, block)?.component;
+    return Component ? <Component block={block} /> : null;
+  })
+}

package/src/astro/analytics.ts

@@ -0,0 +1,76 @@
+/**
+ * Google Analytics 4 consumer of the consent system.
+ *
+ * gtag.js is loaded only once the "analytics" service has been granted. On
+ * revocation GA is switched off through its official opt-out flag.
+ *
+ * NEVER paste a gtag.js snippet into a layout instead of this. A snippet loads
+ * on page view — before consent — which defeats the entire system. The loader
+ * below is created in code, after the decision. See CLAUDE.md §7.
+ *
+ * Browser-only.
+ */
+
+import { onConsentChange } from "./consent";
+
+declare global {
+  interface Window {
+    dataLayer?: unknown[];
+    gtag?: (...args: unknown[]) => void;
+    [key: `ga-disable-${string}`]: boolean | undefined;
+  }
+}
+
+let loaded = false;
+
+function loadAnalytics(measurementId: string): void {
+  if (loaded) return;
+  loaded = true;
+
+  window.dataLayer = window.dataLayer || [];
+  // Must push `arguments`, not a rest-parameter array: gtag.js only executes
+  // Arguments objects and silently ignores arrays — no config, no hits.
+  window.gtag = function gtag() {
+    window.dataLayer!.push(arguments);
+  };
+  window.gtag("js", new Date());
+  window.gtag("config", measurementId, { anonymize_ip: true });
+
+  const script = document.createElement("script");
+  script.async = true;
+  script.src = `https://www.googletagmanager.com/gtag/js?id=${encodeURIComponent(measurementId)}`;
+  document.head.appendChild(script);
+}
+
+/**
+ * Connects GA to the consent manager (service id "analytics").
+ * Idempotent — safe to call once per page.
+ */
+export function bindAnalyticsToConsent(measurementId: string): void {
+  if (!measurementId) return;
+
+  onConsentChange("analytics", (granted) => {
+    if (granted) {
+      window[`ga-disable-${measurementId}`] = false;
+      loadAnalytics(measurementId);
+    } else {
+      // Official GA opt-out: an already loaded gtag stops sending.
+      window[`ga-disable-${measurementId}`] = true;
+    }
+  });
+}
+
+/**
+ * Fires a GA4 event — a silent no-op without consent or without GA loaded.
+ *
+ * Keep the event list short and tied to conversions. Pageviews, scrolls and
+ * outbound clicks come from GA4 Enhanced Measurement automatically, as long as
+ * the site does full page loads. With a client-side router you must fire
+ * `page_view` yourself — see CLAUDE.md §6.
+ */
+export function trackEvent(
+  name: string,
+  params: Record<string, string | number> = {}
+): void {
+  window.gtag?.("event", name, params);
+}

package/src/astro/consent-ui.ts

@@ -0,0 +1,108 @@
+/**
+ * Behaviour of the consent banner and embed gates. Markup, styling and copy
+ * belong to the site (they are design, and in the audience's language); this
+ * module only wires them up through data attributes:
+ *
+ *   banner  input[name="consent-service"][value=<id>]   one per service
+ *           [data-consent-accept-all] [data-consent-decline] [data-consent-save]
+ *   page    [data-consent-settings]                     reopens the banner
+ *   gate    [data-consent-gate=<id>] containing
+ *           [data-consent-placeholder] [data-consent-allow]
+ *           <template data-consent-content>             revealed after consent
+ *
+ * "Accept all" and "Decline" must carry equal visual weight in the markup —
+ * no dark patterns (CLAUDE.md §7).
+ *
+ * Browser-only.
+ */
+import { getChoices, onConsentChange, resetConsent, saveChoices } from "./consent";
+import { trackEvent } from "./analytics";
+
+export interface ConsentBannerOptions {
+  /** Class that hides the banner. Default: "hidden". */
+  hiddenClass?: string;
+}
+
+/** Wires a banner element for the given service ids. */
+export function initConsentBanner(
+  banner: HTMLElement,
+  serviceIds: string[],
+  { hiddenClass = "hidden" }: ConsentBannerOptions = {}
+): void {
+  const boxes = () =>
+    Array.from(
+      banner.querySelectorAll<HTMLInputElement>('input[name="consent-service"]')
+    );
+
+  const show = () => {
+    const stored = getChoices() ?? {};
+    for (const box of boxes()) box.checked = stored[box.value] === true;
+    banner.classList.remove(hiddenClass);
+  };
+  const hide = () => banner.classList.add(hiddenClass);
+
+  const decide = (value: (id: string) => boolean) => {
+    saveChoices(Object.fromEntries(serviceIds.map((id) => [id, value(id)])));
+    hide();
+  };
+
+  // Ask only while at least one registered service has no decision yet.
+  const stored = getChoices();
+  const undecided = serviceIds.some((id) => !stored || !(id in stored));
+  if (undecided) show();
+
+  banner
+    .querySelector("[data-consent-accept-all]")
+    ?.addEventListener("click", () => decide(() => true));
+
+  banner
+    .querySelector("[data-consent-decline]")
+    ?.addEventListener("click", () => decide(() => false));
+
+  banner.querySelector("[data-consent-save]")?.addEventListener("click", () => {
+    const checked = new Set(boxes().filter((b) => b.checked).map((b) => b.value));
+    decide((id) => checked.has(id));
+  });
+
+  // "Cookie settings": clear decisions and ask again.
+  document.querySelectorAll("[data-consent-settings]").forEach((el) =>
+    el.addEventListener("click", () => {
+      resetConsent();
+      show();
+    })
+  );
+}
+
+/**
+ * Two-click gates for third-party embeds. The slot content sits in a
+ * <template> and enters the DOM only after consent — a hidden iframe would
+ * still load.
+ */
+export function initConsentGates(root: ParentNode = document): void {
+  root.querySelectorAll<HTMLElement>("[data-consent-gate]").forEach((gate) => {
+    const service = gate.dataset.consentGate!;
+    const placeholder = gate.querySelector<HTMLElement>("[data-consent-placeholder]");
+    const template = gate.querySelector<HTMLTemplateElement>("[data-consent-content]");
+
+    const reveal = () => {
+      if (!template || gate.dataset.revealed === "true") return;
+      gate.dataset.revealed = "true";
+      placeholder?.remove();
+      gate.appendChild(template.content.cloneNode(true));
+    };
+
+    onConsentChange(service, (granted) => granted && reveal());
+
+    gate.querySelector("[data-consent-allow]")?.addEventListener("click", () => {
+      saveChoices({ [service]: true });
+    });
+  });
+}
+
+/** Email clicks are a conversion path worth measuring. A no-op without consent. */
+export function trackMailtoClicks(): void {
+  document.addEventListener("click", (event) => {
+    const link = (event.target as Element | null)?.closest?.('a[href^="mailto:"]');
+    if (link) trackEvent("mailto_click", { page_path: location.pathname });
+  });
+}

package/src/astro/consent.ts

@@ -0,0 +1,78 @@
+/**
+ * Generic consent manager (GDPR opt-in).
+ *
+ * Services are registered by the site (its consent-services list); this store
+ * only keeps decisions and notifies consumers. It knows nothing about Google Analytics
+ * & co., which is what makes it reusable for any service (analytics, embeds,
+ * maps, …).
+ *
+ * Browser-only.
+ */
+
+// localStorage is per origin, so no site prefix is needed. Bump the suffix if
+// the stored shape ever changes — an old value must never be read as a new one.
+const STORAGE_KEY = "consent-v1";
+const EVENT_NAME = "consent-changed";
+
+/** serviceId → granted? */
+export type ConsentChoices = Record<string, boolean>;
+
+/** All stored decisions — null when nothing has been decided yet. */
+export function getChoices(): ConsentChoices | null {
+  try {
+    const raw = localStorage.getItem(STORAGE_KEY);
+    if (!raw) return null;
+    const parsed = JSON.parse(raw);
+    return typeof parsed === "object" && parsed !== null ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Decision for a single service — null means "not asked yet". */
+export function getConsent(serviceId: string): boolean | null {
+  const choices = getChoices();
+  if (!choices || !(serviceId in choices)) return null;
+  return choices[serviceId] === true;
+}
+
+/** Stores decisions (merged with existing ones) and notifies every consumer. */
+export function saveChoices(update: ConsentChoices): void {
+  const merged = { ...(getChoices() ?? {}), ...update };
+  try {
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(merged));
+  } catch {
+    // Storage unavailable (private mode, quota) — the decision then holds for
+    // this page view only. Better than throwing in the middle of a click.
+  }
+  window.dispatchEvent(new CustomEvent(EVENT_NAME, { detail: merged }));
+}
+
+/** Clears all decisions — used by the footer "cookie settings" link. */
+export function resetConsent(): void {
+  try {
+    localStorage.removeItem(STORAGE_KEY);
+  } catch {
+    /* noop */
+  }
+  window.dispatchEvent(new CustomEvent(EVENT_NAME, { detail: {} }));
+}
+
+/**
+ * Subscribes to changes for one service. The callback fires immediately with
+ * the current state (if already decided) and on every change afterwards — so
+ * consumers never need to care whether consent was stored earlier or granted
+ * just now.
+ */
+export function onConsentChange(
+  serviceId: string,
+  callback: (granted: boolean) => void
+): void {
+  const current = getConsent(serviceId);
+  if (current !== null) callback(current);
+
+  window.addEventListener(EVENT_NAME, (event) => {
+    const choices = (event as CustomEvent<ConsentChoices>).detail;
+    if (serviceId in choices) callback(choices[serviceId] === true);
+  });
+}

package/src/astro/index.ts

@@ -0,0 +1,4 @@
+export * from "./consent";
+export * from "./analytics";
+export * from "./consent-ui";
+export * from "./routes";

package/src/astro/routes.ts

@@ -0,0 +1,76 @@
+import type { APIContext } from "astro";
+import {
+  buildLlmsTxt,
+  HOME_SLUG,
+  type BaseBlock,
+  type BlockRegistry,
+  type CmsRepository,
+} from "@janmarkuslanger/astro-strapi-platform/core";
+
+/**
+ * Route logic shared by every site. A site's route file stays a typed
+ * one-liner, so platform fixes arrive with a version bump; a site that needs
+ * something else replaces its file — nothing here is required.
+ *
+ *   // src/pages/llms.txt.ts
+ *   export const GET: APIRoute = llmsTxtRoute(cms, BLOCKS);
+ */
+
+type Route = (context: Pick<APIContext, "site">) => Promise<Response>;
+
+const text = (body: string) =>
+  new Response(body, { headers: { "Content-Type": "text/plain; charset=utf-8" } });
+
+const siteUrlOf = (site: URL | undefined) => String(site ?? "").replace(/\/$/, "");
+
+/**
+ * `getStaticPaths` for `[...slug].astro`: every CMS page, the home page at
+ * "/" (see HOME_SLUG). New pages need no code.
+ */
+export async function pagePaths<B extends BaseBlock, P extends object, G extends object>(
+  cms: CmsRepository<B, P, G>
+) {
+  const pages = await cms.listPages();
+  return pages.map((page) => ({
+    params: { slug: page.slug === HOME_SLUG ? undefined : page.slug },
+    props: { page },
+  }));
+}
+
+/** `llms.txt`, generated from the CMS at build time, never hand-maintained. */
+export function llmsTxtRoute<B extends BaseBlock, P extends object, G extends object>(
+  cms: CmsRepository<B, P, G>,
+  blocks: BlockRegistry<B>
+): Route {
+  return async ({ site }) => {
+    const [global, pages] = await Promise.all([cms.getGlobal(), cms.listPages()]);
+    return text(buildLlmsTxt(global, pages, siteUrlOf(site), blocks));
+  };
+}
+
+export interface RobotsOptions {
+  /**
+   * AI crawlers (GPTBot, ClaudeBot, PerplexityBot, Google-Extended) are
+   * allowed by default: the site wants to be found by generative engines
+   * (see llms.txt). `false` disallows them.
+   */
+  aiCrawlers?: boolean;
+}
+
+const AI_CRAWLERS = ["GPTBot", "ClaudeBot", "PerplexityBot", "Google-Extended"];
+
+export function robotsTxt(siteUrl: string, { aiCrawlers = true }: RobotsOptions = {}): string {
+  const rule = aiCrawlers ? "Allow: /" : "Disallow: /";
+  return [
+    "User-agent: *",
+    "Allow: /",
+    "",
+    ...AI_CRAWLERS.flatMap((agent) => [`User-agent: ${agent}`, rule, ""]),
+    `Sitemap: ${siteUrl}/sitemap-index.xml`,
+    "",
+  ].join("\n");
+}
+
+export function robotsTxtRoute(options: RobotsOptions = {}): Route {
+  return async ({ site }) => text(robotsTxt(siteUrlOf(site), options));
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.