@arpsw/astro-cms 0.3.1

package/LICENSE

@@ -0,0 +1,4 @@
+Copyright (c) ARP.software. All rights reserved.
+
+This package is proprietary and intended for use within ARP.software projects.
+Not licensed for redistribution.

package/README.md

@@ -0,0 +1,203 @@
+# @arpsw/astro-cms
+
+Astro integration for the **ARP (Laravel) CMS**. It packages the wiring every
+ARP CMS site repeats — the API client, types, i18n + locale/path resolution, and
+config — so a new site is *install → configure → design* instead of fork-and-sync.
+
+Modelled on [`@storyblok/astro`](https://github.com/storyblok/monoblok/tree/main/packages/astro):
+a single integration in `astro.config`, plus runtime helpers and a block
+dispatcher. The CMS is multi-site; one deployment serves one site (`site` slug).
+
+> **Status — `0.x` (pre-release).** Shipped: the `arpCms()` integration (i18n
+> routing + the `virtual:arp-cms` config module), the CMS client, API types,
+> i18n/path resolution, and `resolveRequest()`. Landing next: the `<CmsBlock>`
+> dispatcher (you currently map block types in the site). See **Roadmap**.
+
+## Requirements
+
+- Astro `^6`
+- Node `>= 22.12.0`
+- A reachable ARP CMS API (Laravel), e.g. `https://arp-agiledrop.test` in dev
+
+## Install
+
+The package is published to the **public npm registry** under the `@arpsw`
+scope — no registry config or auth token required:
+
+```bash
+npm install @arpsw/astro-cms
+```
+
+## Configure
+
+Register the integration in `astro.config.ts`. Wire the values from the site's
+own `.env` — the integration runs in Node before Vite, so it can't read
+`import.meta.env` itself:
+
+```ts
+import { defineConfig } from 'astro/config';
+import cloudflare from '@astrojs/cloudflare';
+import arpCms from '@arpsw/astro-cms';
+
+export default defineConfig({
+  adapter: cloudflare(),
+  integrations: [
+    arpCms({
+      baseUrl: process.env.CMS_API_BASE_URL ?? 'http://arp-agiledrop.test',
+      site: process.env.CMS_SITE ?? 'agiledrop',
+      locales: ['en', 'sl'],          // first is the fallback default
+      defaultLocale: process.env.DEFAULT_LOCALE, // optional; must be in `locales`
+      menuSlug: process.env.CMS_MENU_SLUG ?? 'main',
+      previewToken: process.env.CMS_PREVIEW_TOKEN,
+      websiteUrls: {
+        en: process.env.WEBSITE_URL_EN,
+        sl: process.env.WEBSITE_URL_SL,
+      },
+    }),
+  ],
+});
+```
+
+The integration then, on `astro:config:setup`:
+
+- sets Astro's `i18n: { locales, defaultLocale, routing: { prefixDefaultLocale: false } }`,
+- applies the `publicDir` dev workaround (Astro/Vite trailing-slash bug),
+- exposes the resolved config to runtime code as the **`virtual:arp-cms`** module.
+
+You do **not** repeat the `i18n` block or the `publicDir` tweak in your own config.
+
+## Render content
+
+Each site keeps a thin catch-all that wraps **its own** layout and maps block
+types to **its own** components. Import runtime helpers from the `/runtime`
+subpath (the `.` entry is the integration, kept free of runtime imports so it's
+safe in `astro.config`):
+
+```astro
+---
+// src/pages/[...slug].astro
+import Base from '../layouts/Base.astro';
+import { resolveRequest } from '@arpsw/astro-cms/runtime';
+import HomeHero from '../components/blocks/HomeHero.astro';
+import Features from '../components/blocks/Features.astro';
+
+const blocks = { home_hero: HomeHero, features: Features };
+
+const { locale, resolved, menu, redirect } = await resolveRequest(Astro);
+if (redirect) return Astro.redirect(redirect.to, redirect.code);
+// resolveRequest already set Astro.response.status + Cache-Control.
+---
+<Base mainMenu={menu?.items ?? []}>
+  {resolved?.type === 'page' &&
+    resolved.data.blocks.map((block) => {
+      const Cmp = blocks[block.type];
+      return Cmp ? <Cmp {...block} {locale} /> : null;
+    })}
+</Base>
+```
+
+`resolveRequest()` encapsulates locale/path resolution → the CMS `resolve`
+lookup → the nav menu fetch → the edge `Cache-Control` headers. The route stays
+~15 lines; the package owns the plumbing, the site owns the design.
+
+### Optional: `<CmsBlock>`
+
+For sites whose blocks share a uniform prop signature, a generic dispatcher
+saves the `block.type` switch:
+
+```astro
+import CmsBlock from '@arpsw/astro-cms/CmsBlock.astro';
+import Hero from '../components/blocks/Hero.astro';
+const components = { hero: Hero, features: Features };
+...
+{page.blocks.map((block) => <CmsBlock {block} {components} {locale} />)}
+```
+
+It renders `components[block.type]` with the whole `block` (read `block.data`)
+plus any extra props; unknown types render nothing. If your blocks need
+**per-type props or per-block typed `data`** (e.g. only the first block gets
+`isFirst`), hand-write a renderer with a `block.type` switch instead — that
+stays fully type-safe.
+
+## Media & i18n helpers (`/runtime`)
+
+**Media** — normalise the DAM picker shape (`MediaAsset | MediaAsset[] | null`):
+
+```ts
+import { assetSrc, assetAlt, firstAsset, assetFocalPosition } from '@arpsw/astro-cms/runtime';
+const src = assetSrc(block.image, 'large');   // best size, falls back to .url
+const alt = assetAlt(block.image);            // alt → title → ''
+const pos = assetFocalPosition(block.image);  // "50% 30%" for object-position, or undefined
+```
+
+**Language switcher** — one entry per configured locale (labels from `localeMeta`):
+
+```ts
+import { languageSwitchEntries, isRTL } from '@arpsw/astro-cms/runtime';
+const entries = languageSwitchEntries(Astro.url); // [{ locale, code, native, href, isActive, hreflang }]
+```
+
+**UI translations** — the package owns the *mechanism*, the site owns the
+*content*. Define a per-locale dictionary and get a typed lookup:
+
+```ts
+// site src/i18n.ts
+import { makeTranslator } from '@arpsw/astro-cms/runtime';
+export const t = makeTranslator({
+  en: { footer: { contact: 'Contact us' } },
+  sl: { footer: { contact: 'Kontaktirajte nas' } },
+});
+// component: const s = t(locale); s.footer.contact   (falls back to default locale)
+```
+
+## Options
+
+| Option | Required | Default | Notes |
+| --- | --- | --- | --- |
+| `baseUrl` | ✓ | — | CMS API base URL; trailing slashes trimmed |
+| `site` | ✓ | — | Multi-site slug (or numeric id) |
+| `locales` | ✓ | — | Locale codes; first is the fallback default |
+| `defaultLocale` | | `locales[0]` | Must be one of `locales`, else ignored |
+| `menuSlug` | | `"main"` | Nav menu slug |
+| `previewToken` | | — | Bearer for `preview/*`; omit to disable preview |
+| `cache` | | sensible defaults | `Cache-Control` overrides (`page`/`notFound`/`error`/`preview`) |
+| `websiteUrls` | | `{}` | Per-locale canonical URLs; unset → path-prefix routing |
+| `localeMeta` | | `{}` | Per-locale display data (`code`, `native`, `english?`, `dir?`) for the language switcher + RTL |
+
+## Local development of this package
+
+No monorepo — link a local checkout into a site while iterating:
+
+```bash
+# in this package
+npm run build            # or: npm run dev  (tsup --watch)
+npm link
+
+# in the consuming site
+npm link @arpsw/astro-cms
+```
+
+`npm run check` type-checks; `npm run build` emits `dist/` (ESM + `.d.ts`).
+
+## Roadmap
+
+- ✅ CMS client (`getPage`, `resolvePath`, `listPosts`, `getMenu`,
+  `getWebform`, …), API types, i18n/path resolution (`resolveRequest`,
+  `resolveLocaleAndPath`, `getLocaleUrl`, `localePath`, `linkHref`). First
+  consumer: `astro-website` (agiledrop).
+- ✅ `<CmsBlock>` — optional generic dispatcher (`@arpsw/astro-cms/CmsBlock.astro`).
+  Per-block typed renderers remain the recommended pattern for varied props.
+- later — optional `injectRoute` for the catch-all + preview routes, a
+  translation (UI-strings) system + `media` helper + per-locale display
+  metadata (needed before `arp-software-website` can adopt the package), and
+  `types` codegen from the Laravel API resources.
+
+## Publishing
+
+Tag a release; CI (`.github/workflows/release.yml`) builds and publishes to
+GitHub Packages:
+
+```bash
+npm version patch        # bumps package.json + creates the tag
+git push --follow-tags
+```

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+import { AstroIntegration } from 'astro';
+import { A as ArpCmsOptions } from './options-O5HIKY42.js';
+export { C as CacheConfig, L as LocaleMeta, R as ResolvedArpCmsConfig } from './options-O5HIKY42.js';
+
+/**
+ * The ARP CMS Astro integration.
+ *
+ * Wires the boilerplate every ARP CMS site repeats: it configures Astro's i18n
+ * routing from `locales`/`defaultLocale`, applies the `publicDir` dev workaround,
+ * and publishes the resolved connection/locale/cache config to runtime code
+ * through the `virtual:arp-cms` module (consumed by `@arpsw/astro-cms`'s client
+ * and i18n helpers).
+ */
+declare function arpCms(options: ArpCmsOptions): AstroIntegration;
+
+export { ArpCmsOptions, arpCms, arpCms as default };

package/dist/index.js

@@ -0,0 +1,98 @@
+// src/integration.ts
+import { fileURLToPath } from "url";
+
+// src/options.ts
+var DEFAULT_CACHE = {
+  page: "public, max-age=0, s-maxage=3600, stale-while-revalidate=86400",
+  notFound: "public, max-age=0, s-maxage=60",
+  error: "no-store",
+  preview: "no-store, no-cache, must-revalidate"
+};
+var trimTrailingSlashes = (value) => value.replace(/\/+$/, "");
+function resolveOptions(options) {
+  if (!options.locales?.length) {
+    throw new Error("[@arpsw/astro-cms] `locales` must list at least one locale.");
+  }
+  const fallback = options.locales[0];
+  const defaultLocale = options.defaultLocale && options.locales.includes(options.defaultLocale) ? options.defaultLocale : fallback;
+  return {
+    cms: {
+      baseUrl: trimTrailingSlashes(options.baseUrl),
+      site: options.site.trim(),
+      previewToken: options.previewToken || void 0,
+      menuSlug: (options.menuSlug ?? "main").trim()
+    },
+    cache: { ...DEFAULT_CACHE, ...options.cache },
+    websiteUrls: options.websiteUrls ?? {},
+    contentTypePaths: options.contentTypePaths ?? {},
+    localeMeta: options.localeMeta ?? {},
+    locales: [...options.locales],
+    defaultLocale
+  };
+}
+
+// src/integration.ts
+var VIRTUAL_ID = "virtual:arp-cms";
+var RESOLVED_VIRTUAL_ID = "\0" + VIRTUAL_ID;
+function arpCms(options) {
+  const resolved = resolveOptions(options);
+  return {
+    name: "@arpsw/astro-cms",
+    hooks: {
+      "astro:config:setup": ({ config, updateConfig, logger }) => {
+        updateConfig({
+          i18n: {
+            locales: [...resolved.locales],
+            defaultLocale: resolved.defaultLocale,
+            // Full object: `astro:config:setup`'s updateConfig uses the resolved
+            // (strict) config type, unlike the shorthand defineConfig accepts.
+            // Default-locale pages live at the root; `redirectToDefaultLocale`
+            // must be false when `prefixDefaultLocale` is false (Astro rejects
+            // true here — it would risk redirect loops).
+            routing: {
+              prefixDefaultLocale: false,
+              redirectToDefaultLocale: false,
+              fallbackType: "redirect"
+            }
+          },
+          vite: {
+            plugins: [virtualConfigPlugin(resolved)],
+            // Astro passes `publicDir` with a trailing slash, which makes Vite's
+            // initPublicFiles strip the leading slash from cached filenames and
+            // 404 every `public/` asset in dev. Pass it explicitly (no trailing
+            // slash) to bypass the cached path.
+            publicDir: fileURLToPath(config.publicDir)
+          }
+        });
+        logger.info(
+          `serving CMS site "${resolved.cms.site}" \xB7 locales [${resolved.locales.join(
+            ", "
+          )}] \xB7 default "${resolved.defaultLocale}"`
+        );
+      }
+    }
+  };
+}
+function virtualConfigPlugin(resolved) {
+  return {
+    name: "arp-cms:virtual-config",
+    resolveId(id) {
+      if (id === VIRTUAL_ID) {
+        return RESOLVED_VIRTUAL_ID;
+      }
+      return void 0;
+    },
+    load(id) {
+      if (id === RESOLVED_VIRTUAL_ID) {
+        return `export const config = ${JSON.stringify(resolved)};
+export default config;`;
+      }
+      return void 0;
+    }
+  };
+}
+export {
+  arpCms,
+  arpCms as default
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/integration.ts","../src/options.ts"],"sourcesContent":["import { fileURLToPath } from 'node:url';\nimport type { AstroIntegration } from 'astro';\nimport type { Plugin } from 'vite';\nimport { resolveOptions, type ArpCmsOptions, type ResolvedArpCmsConfig } from './options';\n\nconst VIRTUAL_ID = 'virtual:arp-cms';\nconst RESOLVED_VIRTUAL_ID = '\\0' + VIRTUAL_ID;\n\n/**\n * The ARP CMS Astro integration.\n *\n * Wires the boilerplate every ARP CMS site repeats: it configures Astro's i18n\n * routing from `locales`/`defaultLocale`, applies the `publicDir` dev workaround,\n * and publishes the resolved connection/locale/cache config to runtime code\n * through the `virtual:arp-cms` module (consumed by `@arpsw/astro-cms`'s client\n * and i18n helpers).\n */\nexport function arpCms(options: ArpCmsOptions): AstroIntegration {\n  const resolved = resolveOptions(options);\n\n  return {\n    name: '@arpsw/astro-cms',\n    hooks: {\n      'astro:config:setup': ({ config, updateConfig, logger }) => {\n        updateConfig({\n          i18n: {\n            locales: [...resolved.locales],\n            defaultLocale: resolved.defaultLocale,\n            // Full object: `astro:config:setup`'s updateConfig uses the resolved\n            // (strict) config type, unlike the shorthand defineConfig accepts.\n            // Default-locale pages live at the root; `redirectToDefaultLocale`\n            // must be false when `prefixDefaultLocale` is false (Astro rejects\n            // true here — it would risk redirect loops).\n            routing: {\n              prefixDefaultLocale: false,\n              redirectToDefaultLocale: false,\n              fallbackType: 'redirect',\n            },\n          },\n          vite: {\n            plugins: [virtualConfigPlugin(resolved)],\n            // Astro passes `publicDir` with a trailing slash, which makes Vite's\n            // initPublicFiles strip the leading slash from cached filenames and\n            // 404 every `public/` asset in dev. Pass it explicitly (no trailing\n            // slash) to bypass the cached path.\n            publicDir: fileURLToPath(config.publicDir),\n          },\n        });\n\n        logger.info(\n          `serving CMS site \"${resolved.cms.site}\" · locales [${resolved.locales.join(\n            ', ',\n          )}] · default \"${resolved.defaultLocale}\"`,\n        );\n      },\n    },\n  };\n}\n\n/** Serves the resolved config as the `virtual:arp-cms` module to runtime code. */\nfunction virtualConfigPlugin(resolved: ResolvedArpCmsConfig): Plugin {\n  return {\n    name: 'arp-cms:virtual-config',\n    resolveId(id) {\n      if (id === VIRTUAL_ID) {\n        return RESOLVED_VIRTUAL_ID;\n      }\n      return undefined;\n    },\n    load(id) {\n      if (id === RESOLVED_VIRTUAL_ID) {\n        return `export const config = ${JSON.stringify(resolved)};\\nexport default config;`;\n      }\n      return undefined;\n    },\n  };\n}\n","/**\n * Public options for the `arpCms()` integration, and the resolved, serializable\n * config shape that gets exposed to runtime code via `virtual:arp-cms`.\n *\n * The integration runs in the consumer's `astro.config` (Node, before Vite), so\n * the site passes config explicitly here — typically wired from its own `.env`.\n */\n\n/** Per-locale display metadata for the language switcher + `<html dir>`. */\nexport interface LocaleMeta {\n  /** Short uppercase code shown in the picker (EN, SL). */\n  code: string;\n  /** Endonym — the language's name in its own language. */\n  native: string;\n  /** Exonym in English (optional). */\n  english?: string;\n  /** Text direction; defaults to 'ltr'. */\n  dir?: 'ltr' | 'rtl';\n}\n\n/** Edge (Cloudflare) `Cache-Control` headers set by the SSR routes. */\nexport interface CacheConfig {\n  /** Successful page/post responses. */\n  page: string;\n  /** 404 responses (shorter TTL so new CMS content becomes reachable quickly). */\n  notFound: string;\n  /** Upstream/CMS errors — never cache. */\n  error: string;\n  /** Preview routes — never cache, never index. */\n  preview: string;\n}\n\nexport interface ArpCmsOptions {\n  /** Base URL of the Laravel CMS API (trailing slashes are trimmed). */\n  baseUrl: string;\n  /** Multi-site CMS site this deployment serves (slug preferred, id accepted). */\n  site: string;\n  /** Locale codes this site publishes. The first is the fallback default. */\n  locales: readonly string[];\n  /** Effective default locale; must be one of `locales`. Defaults to `locales[0]`. */\n  defaultLocale?: string;\n  /** Navigation menu slug fetched for the site nav. Defaults to `\"main\"`. */\n  menuSlug?: string;\n  /** Bearer token for the `preview/*` endpoints; omit to disable preview. */\n  previewToken?: string;\n  /** Per-locale `Cache-Control` overrides; sensible defaults are applied. */\n  cache?: Partial<CacheConfig>;\n  /** Per-locale canonical site URLs (no trailing slash); unset → path-prefix routing. */\n  websiteUrls?: Record<string, string | undefined>;\n  /**\n   * Per-content-type, per-locale URL prefixes (e.g. `{ post: { en: 'blog' } }`),\n   * mirroring the CMS `/config` `content_type_paths`. Page has no prefix (it\n   * lives at the site root). Consumed by {@link contentTypePath}.\n   */\n  contentTypePaths?: Record<string, Record<string, string | undefined>>;\n  /** Per-locale display metadata for the language switcher + RTL handling. */\n  localeMeta?: Record<string, LocaleMeta>;\n}\n\n/** Resolved config — serialized into the `virtual:arp-cms` module at build time. */\nexport interface ResolvedArpCmsConfig {\n  cms: {\n    baseUrl: string;\n    site: string;\n    previewToken?: string;\n    menuSlug: string;\n  };\n  cache: CacheConfig;\n  websiteUrls: Record<string, string | undefined>;\n  contentTypePaths: Record<string, Record<string, string | undefined>>;\n  localeMeta: Record<string, LocaleMeta>;\n  locales: readonly string[];\n  defaultLocale: string;\n}\n\nconst DEFAULT_CACHE: CacheConfig = {\n  page: 'public, max-age=0, s-maxage=3600, stale-while-revalidate=86400',\n  notFound: 'public, max-age=0, s-maxage=60',\n  error: 'no-store',\n  preview: 'no-store, no-cache, must-revalidate',\n};\n\nconst trimTrailingSlashes = (value: string): string => value.replace(/\\/+$/, '');\n\nexport function resolveOptions(options: ArpCmsOptions): ResolvedArpCmsConfig {\n  if (!options.locales?.length) {\n    throw new Error('[@arpsw/astro-cms] `locales` must list at least one locale.');\n  }\n\n  const fallback = options.locales[0]!;\n  const defaultLocale =\n    options.defaultLocale && options.locales.includes(options.defaultLocale)\n      ? options.defaultLocale\n      : fallback;\n\n  return {\n    cms: {\n      baseUrl: trimTrailingSlashes(options.baseUrl),\n      site: options.site.trim(),\n      previewToken: options.previewToken || undefined,\n      menuSlug: (options.menuSlug ?? 'main').trim(),\n    },\n    cache: { ...DEFAULT_CACHE, ...options.cache },\n    websiteUrls: options.websiteUrls ?? {},\n    contentTypePaths: options.contentTypePaths ?? {},\n    localeMeta: options.localeMeta ?? {},\n    locales: [...options.locales],\n    defaultLocale,\n  };\n}\n"],"mappings":";AAAA,SAAS,qBAAqB;;;AC2E9B,IAAM,gBAA6B;AAAA,EACjC,MAAM;AAAA,EACN,UAAU;AAAA,EACV,OAAO;AAAA,EACP,SAAS;AACX;AAEA,IAAM,sBAAsB,CAAC,UAA0B,MAAM,QAAQ,QAAQ,EAAE;AAExE,SAAS,eAAe,SAA8C;AAC3E,MAAI,CAAC,QAAQ,SAAS,QAAQ;AAC5B,UAAM,IAAI,MAAM,6DAA6D;AAAA,EAC/E;AAEA,QAAM,WAAW,QAAQ,QAAQ,CAAC;AAClC,QAAM,gBACJ,QAAQ,iBAAiB,QAAQ,QAAQ,SAAS,QAAQ,aAAa,IACnE,QAAQ,gBACR;AAEN,SAAO;AAAA,IACL,KAAK;AAAA,MACH,SAAS,oBAAoB,QAAQ,OAAO;AAAA,MAC5C,MAAM,QAAQ,KAAK,KAAK;AAAA,MACxB,cAAc,QAAQ,gBAAgB;AAAA,MACtC,WAAW,QAAQ,YAAY,QAAQ,KAAK;AAAA,IAC9C;AAAA,IACA,OAAO,EAAE,GAAG,eAAe,GAAG,QAAQ,MAAM;AAAA,IAC5C,aAAa,QAAQ,eAAe,CAAC;AAAA,IACrC,kBAAkB,QAAQ,oBAAoB,CAAC;AAAA,IAC/C,YAAY,QAAQ,cAAc,CAAC;AAAA,IACnC,SAAS,CAAC,GAAG,QAAQ,OAAO;AAAA,IAC5B;AAAA,EACF;AACF;;;ADxGA,IAAM,aAAa;AACnB,IAAM,sBAAsB,OAAO;AAW5B,SAAS,OAAO,SAA0C;AAC/D,QAAM,WAAW,eAAe,OAAO;AAEvC,SAAO;AAAA,IACL,MAAM;AAAA,IACN,OAAO;AAAA,MACL,sBAAsB,CAAC,EAAE,QAAQ,cAAc,OAAO,MAAM;AAC1D,qBAAa;AAAA,UACX,MAAM;AAAA,YACJ,SAAS,CAAC,GAAG,SAAS,OAAO;AAAA,YAC7B,eAAe,SAAS;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAMxB,SAAS;AAAA,cACP,qBAAqB;AAAA,cACrB,yBAAyB;AAAA,cACzB,cAAc;AAAA,YAChB;AAAA,UACF;AAAA,UACA,MAAM;AAAA,YACJ,SAAS,CAAC,oBAAoB,QAAQ,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA,YAKvC,WAAW,cAAc,OAAO,SAAS;AAAA,UAC3C;AAAA,QACF,CAAC;AAED,eAAO;AAAA,UACL,qBAAqB,SAAS,IAAI,IAAI,mBAAgB,SAAS,QAAQ;AAAA,YACrE;AAAA,UACF,CAAC,mBAAgB,SAAS,aAAa;AAAA,QACzC;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;AAGA,SAAS,oBAAoB,UAAwC;AACnE,SAAO;AAAA,IACL,MAAM;AAAA,IACN,UAAU,IAAI;AACZ,UAAI,OAAO,YAAY;AACrB,eAAO;AAAA,MACT;AACA,aAAO;AAAA,IACT;AAAA,IACA,KAAK,IAAI;AACP,UAAI,OAAO,qBAAqB;AAC9B,eAAO,yBAAyB,KAAK,UAAU,QAAQ,CAAC;AAAA;AAAA,MAC1D;AACA,aAAO;AAAA,IACT;AAAA,EACF;AACF;","names":[]}

package/dist/options-O5HIKY42.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Public options for the `arpCms()` integration, and the resolved, serializable
+ * config shape that gets exposed to runtime code via `virtual:arp-cms`.
+ *
+ * The integration runs in the consumer's `astro.config` (Node, before Vite), so
+ * the site passes config explicitly here — typically wired from its own `.env`.
+ */
+/** Per-locale display metadata for the language switcher + `<html dir>`. */
+interface LocaleMeta {
+    /** Short uppercase code shown in the picker (EN, SL). */
+    code: string;
+    /** Endonym — the language's name in its own language. */
+    native: string;
+    /** Exonym in English (optional). */
+    english?: string;
+    /** Text direction; defaults to 'ltr'. */
+    dir?: 'ltr' | 'rtl';
+}
+/** Edge (Cloudflare) `Cache-Control` headers set by the SSR routes. */
+interface CacheConfig {
+    /** Successful page/post responses. */
+    page: string;
+    /** 404 responses (shorter TTL so new CMS content becomes reachable quickly). */
+    notFound: string;
+    /** Upstream/CMS errors — never cache. */
+    error: string;
+    /** Preview routes — never cache, never index. */
+    preview: string;
+}
+interface ArpCmsOptions {
+    /** Base URL of the Laravel CMS API (trailing slashes are trimmed). */
+    baseUrl: string;
+    /** Multi-site CMS site this deployment serves (slug preferred, id accepted). */
+    site: string;
+    /** Locale codes this site publishes. The first is the fallback default. */
+    locales: readonly string[];
+    /** Effective default locale; must be one of `locales`. Defaults to `locales[0]`. */
+    defaultLocale?: string;
+    /** Navigation menu slug fetched for the site nav. Defaults to `"main"`. */
+    menuSlug?: string;
+    /** Bearer token for the `preview/*` endpoints; omit to disable preview. */
+    previewToken?: string;
+    /** Per-locale `Cache-Control` overrides; sensible defaults are applied. */
+    cache?: Partial<CacheConfig>;
+    /** Per-locale canonical site URLs (no trailing slash); unset → path-prefix routing. */
+    websiteUrls?: Record<string, string | undefined>;
+    /**
+     * Per-content-type, per-locale URL prefixes (e.g. `{ post: { en: 'blog' } }`),
+     * mirroring the CMS `/config` `content_type_paths`. Page has no prefix (it
+     * lives at the site root). Consumed by {@link contentTypePath}.
+     */
+    contentTypePaths?: Record<string, Record<string, string | undefined>>;
+    /** Per-locale display metadata for the language switcher + RTL handling. */
+    localeMeta?: Record<string, LocaleMeta>;
+}
+/** Resolved config — serialized into the `virtual:arp-cms` module at build time. */
+interface ResolvedArpCmsConfig {
+    cms: {
+        baseUrl: string;
+        site: string;
+        previewToken?: string;
+        menuSlug: string;
+    };
+    cache: CacheConfig;
+    websiteUrls: Record<string, string | undefined>;
+    contentTypePaths: Record<string, Record<string, string | undefined>>;
+    localeMeta: Record<string, LocaleMeta>;
+    locales: readonly string[];
+    defaultLocale: string;
+}
+
+export type { ArpCmsOptions as A, CacheConfig as C, LocaleMeta as L, ResolvedArpCmsConfig as R };

package/dist/runtime.d.ts

@@ -0,0 +1,183 @@
+import { Page, Locale, Menu, Post, Webform, PaginatedResponse, PageListItem, Resolved, MediaAsset } from './types.js';
+export { Block, MenuItem, PageMeta, RedirectEnvelope, ResolvedLink, ResolvedNotFound, ResolvedPage, ResolvedPost, ResolvedRedirect, WebformElement } from './types.js';
+import { R as ResolvedArpCmsConfig } from './options-O5HIKY42.js';
+
+declare const config: ResolvedArpCmsConfig;
+
+declare class CmsNotFoundError extends Error {
+    readonly endpoint: string;
+    constructor(endpoint: string);
+}
+declare class CmsApiError extends Error {
+    readonly endpoint: string;
+    readonly status: number;
+    constructor(endpoint: string, status: number, message: string);
+}
+declare function getHomepage(locale: Locale): Promise<Page>;
+declare function resolvePath(path: string, locale: Locale): Promise<Resolved>;
+declare function resolvePathPreview(path: string, locale: Locale): Promise<Resolved>;
+declare function getHomepagePreview(locale: Locale): Promise<Page>;
+declare function getPagePreview(path: string, locale: Locale): Promise<Page>;
+declare function getPostPreview(slug: string, locale: Locale): Promise<Post>;
+type PageOrRedirect = {
+    kind: 'page';
+    page: Page;
+} | {
+    kind: 'redirect';
+    to: string;
+    type: number;
+};
+declare function getPage(path: string, locale: Locale): Promise<PageOrRedirect>;
+declare function listPages(locale: Locale, perPage?: number): Promise<PaginatedResponse<PageListItem>>;
+declare function listPosts(locale: Locale, perPage?: number): Promise<PaginatedResponse<Post>>;
+declare function getPost(slug: string, locale: Locale): Promise<Post>;
+declare function getMenu(slug: string, locale: Locale): Promise<Menu>;
+declare function getWebform(slug: string, locale: Locale): Promise<Webform>;
+interface WebformSubmitInput {
+    slug: string;
+    locale: Locale;
+    payload: Record<string, unknown>;
+}
+declare function submitWebform({ slug, locale, payload, }: WebformSubmitInput): Promise<unknown>;
+
+declare function isLocale(value: string | undefined): value is Locale;
+/**
+ * Local dev / single-domain mode: locale-prefixed path on the current origin.
+ * The effective default locale never gets a prefix.
+ */
+declare function localePath(locale: Locale, path?: string): string;
+/**
+ * Resolve a locale to a full origin URL when one is configured (WEBSITE_URL_*,
+ * surfaced as `config.websiteUrls`). Returns undefined when the locale has no
+ * URL set — caller should fall back to {@link localePath}.
+ */
+declare function getLocaleSite(locale: Locale): URL | undefined;
+/** Build the canonical URL for a locale + path (origin URL if set, else prefix). */
+declare function getLocaleUrl(locale: Locale, path?: string): string;
+/**
+ * URL prefix configured for a content type in a locale (e.g. `post` → `blog`),
+ * from `config.contentTypePaths` (Site settings → `/config` `content_type_paths`).
+ * Returns undefined when unset — Page has no prefix (it lives at the site root).
+ */
+declare function contentTypePath(type: string, locale: Locale): string | undefined;
+/**
+ * Resolve the href for a CMS link. Internal links carry `{locale, path}`, so we
+ * build the per-locale URL from the local website config; external/manual links
+ * (no locale/path) use their literal `url`.
+ */
+declare function linkHref(link: {
+    url?: string | null;
+    locale?: Locale | null;
+    path?: string | null;
+}): string;
+/**
+ * Strip the locale prefix from a request pathname, returning the CMS-facing
+ * path. The CMS itself doesn't know about path prefixes — that's a routing
+ * concern. Default-locale paths are returned unprefixed.
+ */
+declare function stripLocalePrefix(pathname: string): {
+    locale: Locale;
+    path: string;
+};
+/**
+ * Resolve both the active locale AND the CMS-facing path from the request.
+ *
+ *   1. Host match against `config.websiteUrls` (production: one origin/prefix
+ *      per locale) — the host alone determines the locale; the prefix is then
+ *      stripped to yield the logical path.
+ *   2. Path-prefix fallback (`/sl/about` → sl, `/about`) — only when no host
+ *      matches, i.e. dev/test where there's no per-locale domain.
+ */
+declare function resolveLocaleAndPath(url: URL): {
+    locale: Locale;
+    path: string;
+};
+/** Resolve just the active locale (same rules as {@link resolveLocaleAndPath}). */
+declare function resolveLocale(url: URL): Locale;
+/** True when the locale is configured (in `localeMeta`) as right-to-left. */
+declare function isRTL(locale: Locale): boolean;
+/**
+ * UI-strings translation mechanism. The package owns the *shape*; the site owns
+ * the *content*. Pass a per-locale dictionary; get a `(locale) => strings`
+ * lookup that falls back to the default locale then the first entry.
+ *
+ *   // site src/i18n.ts
+ *   export const t = makeTranslator({ en: { cta: 'Contact' }, sl: { cta: 'Kontakt' } });
+ *   // component: const s = t(locale); s.cta
+ */
+declare function makeTranslator<T>(dictionary: Partial<Record<string, T>>): (locale: Locale) => T;
+interface LanguageSwitchEntry {
+    locale: Locale;
+    /** Uppercase code from localeMeta (EN), or the upper-cased locale. */
+    code: string;
+    /** Endonym from localeMeta, or the locale code. */
+    native: string;
+    href: string;
+    hreflang: string;
+    isActive: boolean;
+}
+/**
+ * One entry per configured locale, each linking to the equivalent path in that
+ * locale (host/prefix-aware). Labels come from `localeMeta` (passed to
+ * `arpCms({ localeMeta })`); missing metadata falls back to the locale code.
+ */
+declare function languageSwitchEntries(currentUrl: URL): LanguageSwitchEntry[];
+
+/**
+ * Helpers for the CMS media-asset shape. The DAM MediaAssetPicker returns
+ * `MediaAsset | MediaAsset[] | null` even for single-select, so these normalise
+ * it for block components. Pure functions — no config, importable anywhere.
+ */
+
+type MaybeAsset = MediaAsset | MediaAsset[] | null | undefined;
+/** First asset from the picker shape (array or single), or null. */
+declare function firstAsset(m: MaybeAsset): MediaAsset | null;
+/** Best URL for a size, falling back to the original `url`. */
+declare function assetSrc(m: MaybeAsset, size?: 'large' | 'medium' | 'thumbnail' | 'preview'): string | undefined;
+/** Alt text, falling back to the asset title then empty string. */
+declare function assetAlt(m: MaybeAsset): string;
+/**
+ * CSS `object-position` from the asset's focal point (DAM stores 0–1 floats),
+ * e.g. `"50% 30%"`. Returns undefined when no focal point is set.
+ */
+declare function assetFocalPosition(m: MaybeAsset): string | undefined;
+
+interface ResolveRequestOptions {
+    /** Hit the preview/draft endpoints (sets no-store + noindex). */
+    preview?: boolean;
+}
+interface ResolveRequestResult {
+    /** Active locale resolved from host/path. */
+    locale: Locale;
+    /** CMS-facing logical path (locale prefix stripped). */
+    path: string;
+    /** The resolve envelope, or null if the CMS call errored. */
+    resolved: Resolved | null;
+    /** The site nav menu (config.cms.menuSlug), or null if unavailable. */
+    menu: Menu | null;
+    /** Set when the CMS returned a redirect — the caller should `Astro.redirect`. */
+    redirect: {
+        to: string;
+        code: number;
+    } | null;
+    /** HTTP status that was set on the response. */
+    status: number;
+    /** Human-readable error message when the CMS call failed. */
+    error: string | null;
+}
+interface RequestContext {
+    url: URL;
+    response: {
+        status?: number;
+        headers: Headers;
+    };
+}
+/**
+ * Resolve an incoming request end-to-end: locale/path → CMS `resolve` lookup →
+ * nav menu → response status + edge `Cache-Control` headers. Returns the data
+ * for the route to render; on a CMS redirect it returns `redirect` for the
+ * caller to `return Astro.redirect(redirect.to, redirect.code)`.
+ */
+declare function resolveRequest(ctx: RequestContext, options?: ResolveRequestOptions): Promise<ResolveRequestResult>;
+
+export { CmsApiError, CmsNotFoundError, type LanguageSwitchEntry, Locale, MediaAsset, Menu, Page, PageListItem, type PageOrRedirect, PaginatedResponse, Post, type ResolveRequestOptions, type ResolveRequestResult, Resolved, Webform, type WebformSubmitInput, assetAlt, assetFocalPosition, assetSrc, config, contentTypePath, firstAsset, getHomepage, getHomepagePreview, getLocaleSite, getLocaleUrl, getMenu, getPage, getPagePreview, getPost, getPostPreview, getWebform, isLocale, isRTL, languageSwitchEntries, linkHref, listPages, listPosts, localePath, makeTranslator, resolveLocale, resolveLocaleAndPath, resolvePath, resolvePathPreview, resolveRequest, stripLocalePrefix, submitWebform };

package/dist/runtime.js

@@ -0,0 +1,357 @@
+// src/config.ts
+import { config as virtualConfig } from "virtual:arp-cms";
+var config = virtualConfig;
+
+// src/client.ts
+var API_PREFIX = `/api/cms/v1/sites/${encodeURIComponent(config.cms.site)}`;
+var CmsNotFoundError = class extends Error {
+  constructor(endpoint) {
+    super(`CMS resource not found: ${endpoint}`);
+    this.endpoint = endpoint;
+    this.name = "CmsNotFoundError";
+  }
+  endpoint;
+};
+var CmsApiError = class extends Error {
+  constructor(endpoint, status, message) {
+    super(`CMS API error (${status}) on ${endpoint}: ${message}`);
+    this.endpoint = endpoint;
+    this.status = status;
+    this.name = "CmsApiError";
+  }
+  endpoint;
+  status;
+};
+async function fetchJson(path, options = {}) {
+  const url = new URL(`${API_PREFIX}${path}`, config.cms.baseUrl);
+  if (options.query) {
+    for (const [key, value] of Object.entries(options.query)) {
+      if (value !== void 0) {
+        url.searchParams.set(key, String(value));
+      }
+    }
+  }
+  const headers = {
+    Accept: "application/json"
+  };
+  if (options.locale) {
+    headers["Accept-Language"] = options.locale;
+    if (!url.searchParams.has("locale")) {
+      url.searchParams.set("locale", options.locale);
+    }
+  }
+  if (options.preview) {
+    const token = config.cms.previewToken;
+    if (!token) {
+      throw new Error("CMS preview token is not set (arpCms({ previewToken }))");
+    }
+    headers.Authorization = `Bearer ${token}`;
+  }
+  const response = await fetch(url.toString(), { headers });
+  if (response.status === 404) {
+    throw new CmsNotFoundError(url.pathname);
+  }
+  if (!response.ok) {
+    throw new CmsApiError(url.pathname, response.status, await response.text());
+  }
+  return response.json();
+}
+function unwrap(payload) {
+  if (payload && typeof payload === "object" && "data" in payload) {
+    return payload.data;
+  }
+  return payload;
+}
+async function getHomepage(locale) {
+  return unwrap(await fetchJson("/pages/_homepage", { locale }));
+}
+async function resolvePath(path, locale) {
+  try {
+    return await fetchJson("/resolve", { locale, query: { path } });
+  } catch (e) {
+    if (e instanceof CmsNotFoundError) {
+      return { type: "not_found" };
+    }
+    throw e;
+  }
+}
+async function resolvePathPreview(path, locale) {
+  try {
+    return await fetchJson("/preview/resolve", {
+      locale,
+      query: { path },
+      preview: true
+    });
+  } catch (e) {
+    if (e instanceof CmsNotFoundError) {
+      return { type: "not_found" };
+    }
+    throw e;
+  }
+}
+async function getHomepagePreview(locale) {
+  return unwrap(
+    await fetchJson("/preview/pages/_homepage", { locale, preview: true })
+  );
+}
+async function getPagePreview(path, locale) {
+  const normalized = path.replace(/^\/+/, "");
+  return unwrap(
+    await fetchJson(`/preview/pages/${normalized}`, { locale, preview: true })
+  );
+}
+async function getPostPreview(slug, locale) {
+  return unwrap(
+    await fetchJson(`/preview/posts/${slug}`, { locale, preview: true })
+  );
+}
+async function getPage(path, locale) {
+  const normalized = path.replace(/^\/+/, "");
+  const payload = await fetchJson(`/pages/${normalized}`, {
+    locale
+  });
+  if ("redirect" in payload) {
+    return { kind: "redirect", to: payload.redirect.to, type: payload.redirect.type };
+  }
+  return { kind: "page", page: unwrap(payload) };
+}
+async function listPages(locale, perPage = 100) {
+  return fetchJson("/pages", {
+    locale,
+    query: { per_page: perPage }
+  });
+}
+async function listPosts(locale, perPage = 25) {
+  return fetchJson("/posts", {
+    locale,
+    query: { per_page: perPage }
+  });
+}
+async function getPost(slug, locale) {
+  return unwrap(await fetchJson(`/posts/${slug}`, { locale }));
+}
+async function getMenu(slug, locale) {
+  return unwrap(await fetchJson(`/menus/${slug}`, { locale }));
+}
+async function getWebform(slug, locale) {
+  return unwrap(await fetchJson(`/webforms/${slug}`, { locale }));
+}
+async function submitWebform({
+  slug,
+  locale,
+  payload
+}) {
+  const url = new URL(`${API_PREFIX}/webforms/${slug}/submit`, config.cms.baseUrl);
+  const response = await fetch(url.toString(), {
+    method: "POST",
+    headers: {
+      Accept: "application/json",
+      "Content-Type": "application/json",
+      "Accept-Language": locale
+    },
+    body: JSON.stringify(payload)
+  });
+  if (!response.ok) {
+    throw new CmsApiError(url.pathname, response.status, await response.text());
+  }
+  return response.json();
+}
+
+// src/i18n.ts
+function isLocale(value) {
+  return !!value && config.locales.includes(value);
+}
+function localePath(locale, path = "/") {
+  const clean = path.startsWith("/") ? path : `/${path}`;
+  if (locale === config.defaultLocale) {
+    return clean;
+  }
+  return clean === "/" ? `/${locale}/` : `/${locale}${clean}`;
+}
+function getLocaleSite(locale) {
+  const raw = config.websiteUrls[locale];
+  if (!raw) return void 0;
+  try {
+    return new URL(raw);
+  } catch {
+    return void 0;
+  }
+}
+function getLocaleUrl(locale, path = "/") {
+  const site = getLocaleSite(locale);
+  if (!site) {
+    return localePath(locale, path);
+  }
+  const clean = path.startsWith("/") ? path : `/${path}`;
+  const sitePrefix = site.pathname.replace(/\/+$/, "");
+  return `${site.origin}${sitePrefix}${clean === "/" ? "" : clean}`;
+}
+function contentTypePath(type, locale) {
+  return config.contentTypePaths[type]?.[locale] ?? void 0;
+}
+function linkHref(link) {
+  if (link.locale && link.path != null && isLocale(link.locale)) {
+    return getLocaleUrl(link.locale, link.path);
+  }
+  return link.url ?? "#";
+}
+function stripLocalePrefix(pathname) {
+  const segments = pathname.split("/").filter(Boolean);
+  const first = segments[0];
+  if (first && first !== config.defaultLocale && config.locales.includes(first)) {
+    const rest = segments.slice(1).join("/");
+    return { locale: first, path: rest === "" ? "/" : `/${rest}` };
+  }
+  return { locale: config.defaultLocale, path: pathname === "" ? "/" : pathname };
+}
+function resolveLocaleAndPath(url) {
+  const requestHost = url.hostname.toLowerCase();
+  const requestPath = url.pathname || "/";
+  for (const code of config.locales) {
+    const site = getLocaleSite(code);
+    if (!site || site.hostname.toLowerCase() !== requestHost) {
+      continue;
+    }
+    const sitePrefix = site.pathname.replace(/\/+$/, "");
+    if (sitePrefix === "") {
+      return { locale: code, path: requestPath };
+    }
+    if (requestPath === sitePrefix || requestPath.startsWith(sitePrefix + "/")) {
+      return { locale: code, path: requestPath.slice(sitePrefix.length) || "/" };
+    }
+  }
+  return stripLocalePrefix(requestPath);
+}
+function resolveLocale(url) {
+  return resolveLocaleAndPath(url).locale;
+}
+function isRTL(locale) {
+  return (config.localeMeta[locale]?.dir ?? "ltr") === "rtl";
+}
+function makeTranslator(dictionary) {
+  return (locale) => dictionary[locale] ?? dictionary[config.defaultLocale] ?? Object.values(dictionary)[0];
+}
+function languageSwitchEntries(currentUrl) {
+  const { locale: currentLocale, path: logicalPath } = resolveLocaleAndPath(currentUrl);
+  return config.locales.map((l) => {
+    const site = getLocaleSite(l);
+    const href = site ? `${site.origin}${site.pathname.replace(/\/+$/, "")}${logicalPath === "/" ? "" : logicalPath}` : localePath(l, logicalPath);
+    const meta = config.localeMeta[l];
+    return {
+      locale: l,
+      code: meta?.code ?? l.toUpperCase(),
+      native: meta?.native ?? l,
+      href,
+      hreflang: l,
+      isActive: l === currentLocale
+    };
+  });
+}
+
+// src/media.ts
+function firstAsset(m) {
+  if (!m) return null;
+  return Array.isArray(m) ? m[0] ?? null : m;
+}
+function assetSrc(m, size = "large") {
+  const a = firstAsset(m);
+  if (!a) return void 0;
+  return a[size] ?? a.url ?? void 0;
+}
+function assetAlt(m) {
+  const a = firstAsset(m);
+  return a?.alt ?? a?.title ?? "";
+}
+function assetFocalPosition(m) {
+  const focal = firstAsset(m)?.focal;
+  if (!focal || focal.x == null || focal.y == null) return void 0;
+  return `${(focal.x * 100).toFixed(2)}% ${(focal.y * 100).toFixed(2)}%`;
+}
+
+// src/runtime.ts
+async function resolveRequest(ctx, options = {}) {
+  const { locale, path } = resolveLocaleAndPath(ctx.url);
+  let resolved = null;
+  let error = null;
+  let status = 200;
+  try {
+    resolved = options.preview ? await resolvePathPreview(path, locale) : await resolvePath(path, locale);
+  } catch (e) {
+    if (e instanceof CmsApiError) {
+      error = `CMS API returned ${e.status}.`;
+      status = 502;
+    } else {
+      error = e instanceof Error ? e.message : "Unknown error.";
+      status = 500;
+    }
+  }
+  if (resolved?.type === "redirect") {
+    ctx.response.headers.set("Cache-Control", config.cache.page);
+    return {
+      locale,
+      path,
+      resolved,
+      menu: null,
+      redirect: { to: resolved.to, code: resolved.code },
+      status,
+      error
+    };
+  }
+  let menu = null;
+  try {
+    menu = await getMenu(config.cms.menuSlug, locale);
+  } catch {
+  }
+  if (resolved?.type === "not_found") {
+    status = 404;
+  }
+  ctx.response.status = status;
+  ctx.response.headers.set("Cache-Control", cacheHeaderFor(resolved, error, options.preview));
+  if (options.preview) {
+    ctx.response.headers.set("X-Robots-Tag", "noindex, nofollow");
+  }
+  return { locale, path, resolved, menu, redirect: null, status, error };
+}
+function cacheHeaderFor(resolved, error, preview) {
+  if (preview) return config.cache.preview;
+  if (error || !resolved) return config.cache.error;
+  if (resolved.type === "page" || resolved.type === "post") return config.cache.page;
+  if (resolved.type === "not_found") return config.cache.notFound;
+  return config.cache.error;
+}
+export {
+  CmsApiError,
+  CmsNotFoundError,
+  assetAlt,
+  assetFocalPosition,
+  assetSrc,
+  config,
+  contentTypePath,
+  firstAsset,
+  getHomepage,
+  getHomepagePreview,
+  getLocaleSite,
+  getLocaleUrl,
+  getMenu,
+  getPage,
+  getPagePreview,
+  getPost,
+  getPostPreview,
+  getWebform,
+  isLocale,
+  isRTL,
+  languageSwitchEntries,
+  linkHref,
+  listPages,
+  listPosts,
+  localePath,
+  makeTranslator,
+  resolveLocale,
+  resolveLocaleAndPath,
+  resolvePath,
+  resolvePathPreview,
+  resolveRequest,
+  stripLocalePrefix,
+  submitWebform
+};
+//# sourceMappingURL=runtime.js.map

package/dist/runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/config.ts","../src/client.ts","../src/i18n.ts","../src/media.ts","../src/runtime.ts"],"sourcesContent":["/**\n * The resolved runtime config, provided by the `arpCms()` integration through\n * the `virtual:arp-cms` module. Runtime code (client, i18n) reads it from here.\n *\n * The value is imported from the virtual module but re-exported with an explicit\n * type so the emitted `.d.ts` carries a concrete `ResolvedArpCmsConfig` — never a\n * `from 'virtual:arp-cms'` re-export, which consumers couldn't resolve.\n *\n * This module imports a virtual module, so it (and anything that re-exports it)\n * must NOT be pulled into `astro.config` — keep the package's `.` entry free of\n * it. Runtime consumers reach it via the `@arpsw/astro-cms/runtime` subpath.\n */\nimport { config as virtualConfig } from 'virtual:arp-cms';\nimport type { ResolvedArpCmsConfig } from './options';\n\nexport const config: ResolvedArpCmsConfig = virtualConfig;\n","/**\n * Typed client for the ARP CMS API. Connection + site come from the resolved\n * config (`virtual:arp-cms`); every content endpoint is scoped to the site via\n * `/api/cms/v1/sites/{site}`.\n */\nimport { config } from './config';\nimport type {\n  Locale,\n  Menu,\n  Page,\n  PageListItem,\n  PaginatedResponse,\n  Post,\n  RedirectEnvelope,\n  Resolved,\n  Webform,\n} from './types';\n\nconst API_PREFIX = `/api/cms/v1/sites/${encodeURIComponent(config.cms.site)}`;\n\nexport class CmsNotFoundError extends Error {\n  constructor(public readonly endpoint: string) {\n    super(`CMS resource not found: ${endpoint}`);\n    this.name = 'CmsNotFoundError';\n  }\n}\n\nexport class CmsApiError extends Error {\n  constructor(\n    public readonly endpoint: string,\n    public readonly status: number,\n    message: string,\n  ) {\n    super(`CMS API error (${status}) on ${endpoint}: ${message}`);\n    this.name = 'CmsApiError';\n  }\n}\n\ninterface FetchOptions {\n  locale?: Locale;\n  query?: Record<string, string | number | undefined>;\n  preview?: boolean;\n}\n\nasync function fetchJson<T>(path: string, options: FetchOptions = {}): Promise<T> {\n  const url = new URL(`${API_PREFIX}${path}`, config.cms.baseUrl);\n\n  if (options.query) {\n    for (const [key, value] of Object.entries(options.query)) {\n      if (value !== undefined) {\n        url.searchParams.set(key, String(value));\n      }\n    }\n  }\n\n  const headers: Record<string, string> = {\n    Accept: 'application/json',\n  };\n\n  if (options.locale) {\n    headers['Accept-Language'] = options.locale;\n    // Also send locale as a query param. The CMS's cached read routes are\n    // wrapped in Spatie ResponseCache, which hashes by URL+method but not by\n    // headers — relying on Accept-Language alone causes cross-locale cache\n    // poisoning. ?locale=… makes the cache key vary by locale, and the API's\n    // ResolvesApiLocale concern already honours the query param explicitly.\n    if (!url.searchParams.has('locale')) {\n      url.searchParams.set('locale', options.locale);\n    }\n  }\n\n  if (options.preview) {\n    const token = config.cms.previewToken;\n    if (!token) {\n      throw new Error('CMS preview token is not set (arpCms({ previewToken }))');\n    }\n    headers.Authorization = `Bearer ${token}`;\n  }\n\n  const response = await fetch(url.toString(), { headers });\n\n  if (response.status === 404) {\n    throw new CmsNotFoundError(url.pathname);\n  }\n\n  if (!response.ok) {\n    throw new CmsApiError(url.pathname, response.status, await response.text());\n  }\n\n  return response.json() as Promise<T>;\n}\n\nfunction unwrap<T>(payload: { data: T } | T): T {\n  if (payload && typeof payload === 'object' && 'data' in payload) {\n    return (payload as { data: T }).data;\n  }\n  return payload as T;\n}\n\n// --- Pages -----------------------------------------------------------------\n\nexport async function getHomepage(locale: Locale): Promise<Page> {\n  return unwrap(await fetchJson<{ data: Page }>('/pages/_homepage', { locale }));\n}\n\n// --- Resolver --------------------------------------------------------------\n//\n// One call per incoming URL. Laravel decides whether the path is a redirect, a\n// page, a post, or 404. The catch-all switches on the envelope's .type.\n\nexport async function resolvePath(path: string, locale: Locale): Promise<Resolved> {\n  try {\n    return await fetchJson<Resolved>('/resolve', { locale, query: { path } });\n  } catch (e) {\n    if (e instanceof CmsNotFoundError) {\n      return { type: 'not_found' };\n    }\n    throw e;\n  }\n}\n\nexport async function resolvePathPreview(path: string, locale: Locale): Promise<Resolved> {\n  try {\n    return await fetchJson<Resolved>('/preview/resolve', {\n      locale,\n      query: { path },\n      preview: true,\n    });\n  } catch (e) {\n    if (e instanceof CmsNotFoundError) {\n      return { type: 'not_found' };\n    }\n    throw e;\n  }\n}\n\n// --- Preview (draft) -------------------------------------------------------\n\nexport async function getHomepagePreview(locale: Locale): Promise<Page> {\n  return unwrap(\n    await fetchJson<{ data: Page }>('/preview/pages/_homepage', { locale, preview: true }),\n  );\n}\n\nexport async function getPagePreview(path: string, locale: Locale): Promise<Page> {\n  const normalized = path.replace(/^\\/+/, '');\n  return unwrap(\n    await fetchJson<{ data: Page }>(`/preview/pages/${normalized}`, { locale, preview: true }),\n  );\n}\n\nexport async function getPostPreview(slug: string, locale: Locale): Promise<Post> {\n  return unwrap(\n    await fetchJson<{ data: Post }>(`/preview/posts/${slug}`, { locale, preview: true }),\n  );\n}\n\nexport type PageOrRedirect =\n  | { kind: 'page'; page: Page }\n  | { kind: 'redirect'; to: string; type: number };\n\nexport async function getPage(path: string, locale: Locale): Promise<PageOrRedirect> {\n  const normalized = path.replace(/^\\/+/, '');\n  const payload = await fetchJson<{ data: Page } | RedirectEnvelope>(`/pages/${normalized}`, {\n    locale,\n  });\n\n  if ('redirect' in payload) {\n    return { kind: 'redirect', to: payload.redirect.to, type: payload.redirect.type };\n  }\n\n  return { kind: 'page', page: unwrap(payload) };\n}\n\nexport async function listPages(\n  locale: Locale,\n  perPage = 100,\n): Promise<PaginatedResponse<PageListItem>> {\n  return fetchJson<PaginatedResponse<PageListItem>>('/pages', {\n    locale,\n    query: { per_page: perPage },\n  });\n}\n\n// --- Posts -----------------------------------------------------------------\n\nexport async function listPosts(locale: Locale, perPage = 25): Promise<PaginatedResponse<Post>> {\n  return fetchJson<PaginatedResponse<Post>>('/posts', {\n    locale,\n    query: { per_page: perPage },\n  });\n}\n\nexport async function getPost(slug: string, locale: Locale): Promise<Post> {\n  return unwrap(await fetchJson<{ data: Post }>(`/posts/${slug}`, { locale }));\n}\n\n// --- Menus -----------------------------------------------------------------\n\nexport async function getMenu(slug: string, locale: Locale): Promise<Menu> {\n  return unwrap(await fetchJson<{ data: Menu }>(`/menus/${slug}`, { locale }));\n}\n\n// --- Webforms --------------------------------------------------------------\n\nexport async function getWebform(slug: string, locale: Locale): Promise<Webform> {\n  return unwrap(await fetchJson<{ data: Webform }>(`/webforms/${slug}`, { locale }));\n}\n\nexport interface WebformSubmitInput {\n  slug: string;\n  locale: Locale;\n  payload: Record<string, unknown>;\n}\n\nexport async function submitWebform({\n  slug,\n  locale,\n  payload,\n}: WebformSubmitInput): Promise<unknown> {\n  const url = new URL(`${API_PREFIX}/webforms/${slug}/submit`, config.cms.baseUrl);\n  const response = await fetch(url.toString(), {\n    method: 'POST',\n    headers: {\n      Accept: 'application/json',\n      'Content-Type': 'application/json',\n      'Accept-Language': locale,\n    },\n    body: JSON.stringify(payload),\n  });\n\n  if (!response.ok) {\n    throw new CmsApiError(url.pathname, response.status, await response.text());\n  }\n\n  return response.json();\n}\n","/**\n * Locale + path resolution and per-locale URL building, all driven by the\n * resolved config (locales, defaultLocale, websiteUrls).\n *\n * Locale display metadata (native names, RTL `dir`) is intentionally NOT here —\n * that's site UI data, owned by the consuming site's language switcher.\n */\nimport { config } from './config';\nimport type { Locale } from './types';\n\nexport function isLocale(value: string | undefined): value is Locale {\n  return !!value && config.locales.includes(value);\n}\n\n/**\n * Local dev / single-domain mode: locale-prefixed path on the current origin.\n * The effective default locale never gets a prefix.\n */\nexport function localePath(locale: Locale, path: string = '/'): string {\n  const clean = path.startsWith('/') ? path : `/${path}`;\n  if (locale === config.defaultLocale) {\n    return clean;\n  }\n  return clean === '/' ? `/${locale}/` : `/${locale}${clean}`;\n}\n\n/**\n * Resolve a locale to a full origin URL when one is configured (WEBSITE_URL_*,\n * surfaced as `config.websiteUrls`). Returns undefined when the locale has no\n * URL set — caller should fall back to {@link localePath}.\n */\nexport function getLocaleSite(locale: Locale): URL | undefined {\n  const raw = config.websiteUrls[locale];\n  if (!raw) return undefined;\n  try {\n    return new URL(raw);\n  } catch {\n    return undefined;\n  }\n}\n\n/** Build the canonical URL for a locale + path (origin URL if set, else prefix). */\nexport function getLocaleUrl(locale: Locale, path: string = '/'): string {\n  const site = getLocaleSite(locale);\n  if (!site) {\n    return localePath(locale, path);\n  }\n  const clean = path.startsWith('/') ? path : `/${path}`;\n  const sitePrefix = site.pathname.replace(/\\/+$/, '');\n  return `${site.origin}${sitePrefix}${clean === '/' ? '' : clean}`;\n}\n\n/**\n * URL prefix configured for a content type in a locale (e.g. `post` → `blog`),\n * from `config.contentTypePaths` (Site settings → `/config` `content_type_paths`).\n * Returns undefined when unset — Page has no prefix (it lives at the site root).\n */\nexport function contentTypePath(type: string, locale: Locale): string | undefined {\n  return config.contentTypePaths[type]?.[locale] ?? undefined;\n}\n\n/**\n * Resolve the href for a CMS link. Internal links carry `{locale, path}`, so we\n * build the per-locale URL from the local website config; external/manual links\n * (no locale/path) use their literal `url`.\n */\nexport function linkHref(link: {\n  url?: string | null;\n  locale?: Locale | null;\n  path?: string | null;\n}): string {\n  if (link.locale && link.path != null && isLocale(link.locale)) {\n    return getLocaleUrl(link.locale, link.path);\n  }\n  return link.url ?? '#';\n}\n\n/**\n * Strip the locale prefix from a request pathname, returning the CMS-facing\n * path. The CMS itself doesn't know about path prefixes — that's a routing\n * concern. Default-locale paths are returned unprefixed.\n */\nexport function stripLocalePrefix(pathname: string): { locale: Locale; path: string } {\n  const segments = pathname.split('/').filter(Boolean);\n  const first = segments[0];\n\n  if (first && first !== config.defaultLocale && config.locales.includes(first)) {\n    const rest = segments.slice(1).join('/');\n    return { locale: first, path: rest === '' ? '/' : `/${rest}` };\n  }\n\n  return { locale: config.defaultLocale, path: pathname === '' ? '/' : pathname };\n}\n\n/**\n * Resolve both the active locale AND the CMS-facing path from the request.\n *\n *   1. Host match against `config.websiteUrls` (production: one origin/prefix\n *      per locale) — the host alone determines the locale; the prefix is then\n *      stripped to yield the logical path.\n *   2. Path-prefix fallback (`/sl/about` → sl, `/about`) — only when no host\n *      matches, i.e. dev/test where there's no per-locale domain.\n */\nexport function resolveLocaleAndPath(url: URL): { locale: Locale; path: string } {\n  const requestHost = url.hostname.toLowerCase();\n  const requestPath = url.pathname || '/';\n\n  for (const code of config.locales) {\n    const site = getLocaleSite(code);\n    if (!site || site.hostname.toLowerCase() !== requestHost) {\n      continue;\n    }\n\n    const sitePrefix = site.pathname.replace(/\\/+$/, '');\n    if (sitePrefix === '') {\n      return { locale: code, path: requestPath };\n    }\n    if (requestPath === sitePrefix || requestPath.startsWith(sitePrefix + '/')) {\n      return { locale: code, path: requestPath.slice(sitePrefix.length) || '/' };\n    }\n  }\n\n  return stripLocalePrefix(requestPath);\n}\n\n/** Resolve just the active locale (same rules as {@link resolveLocaleAndPath}). */\nexport function resolveLocale(url: URL): Locale {\n  return resolveLocaleAndPath(url).locale;\n}\n\n/** True when the locale is configured (in `localeMeta`) as right-to-left. */\nexport function isRTL(locale: Locale): boolean {\n  return (config.localeMeta[locale]?.dir ?? 'ltr') === 'rtl';\n}\n\n/**\n * UI-strings translation mechanism. The package owns the *shape*; the site owns\n * the *content*. Pass a per-locale dictionary; get a `(locale) => strings`\n * lookup that falls back to the default locale then the first entry.\n *\n *   // site src/i18n.ts\n *   export const t = makeTranslator({ en: { cta: 'Contact' }, sl: { cta: 'Kontakt' } });\n *   // component: const s = t(locale); s.cta\n */\nexport function makeTranslator<T>(dictionary: Partial<Record<string, T>>): (locale: Locale) => T {\n  return (locale: Locale): T =>\n    dictionary[locale] ?? dictionary[config.defaultLocale] ?? Object.values(dictionary)[0]!;\n}\n\nexport interface LanguageSwitchEntry {\n  locale: Locale;\n  /** Uppercase code from localeMeta (EN), or the upper-cased locale. */\n  code: string;\n  /** Endonym from localeMeta, or the locale code. */\n  native: string;\n  href: string;\n  hreflang: string;\n  isActive: boolean;\n}\n\n/**\n * One entry per configured locale, each linking to the equivalent path in that\n * locale (host/prefix-aware). Labels come from `localeMeta` (passed to\n * `arpCms({ localeMeta })`); missing metadata falls back to the locale code.\n */\nexport function languageSwitchEntries(currentUrl: URL): LanguageSwitchEntry[] {\n  const { locale: currentLocale, path: logicalPath } = resolveLocaleAndPath(currentUrl);\n\n  return config.locales.map((l) => {\n    const site = getLocaleSite(l);\n    const href = site\n      ? `${site.origin}${site.pathname.replace(/\\/+$/, '')}${logicalPath === '/' ? '' : logicalPath}`\n      : localePath(l, logicalPath);\n    const meta = config.localeMeta[l];\n\n    return {\n      locale: l,\n      code: meta?.code ?? l.toUpperCase(),\n      native: meta?.native ?? l,\n      href,\n      hreflang: l,\n      isActive: l === currentLocale,\n    };\n  });\n}\n","/**\n * Helpers for the CMS media-asset shape. The DAM MediaAssetPicker returns\n * `MediaAsset | MediaAsset[] | null` even for single-select, so these normalise\n * it for block components. Pure functions — no config, importable anywhere.\n */\nimport type { MediaAsset } from './types';\n\ntype MaybeAsset = MediaAsset | MediaAsset[] | null | undefined;\n\n/** First asset from the picker shape (array or single), or null. */\nexport function firstAsset(m: MaybeAsset): MediaAsset | null {\n  if (!m) return null;\n  return Array.isArray(m) ? (m[0] ?? null) : m;\n}\n\n/** Best URL for a size, falling back to the original `url`. */\nexport function assetSrc(\n  m: MaybeAsset,\n  size: 'large' | 'medium' | 'thumbnail' | 'preview' = 'large',\n): string | undefined {\n  const a = firstAsset(m);\n  if (!a) return undefined;\n  return (a[size] as string | null | undefined) ?? a.url ?? undefined;\n}\n\n/** Alt text, falling back to the asset title then empty string. */\nexport function assetAlt(m: MaybeAsset): string {\n  const a = firstAsset(m);\n  return a?.alt ?? a?.title ?? '';\n}\n\n/**\n * CSS `object-position` from the asset's focal point (DAM stores 0–1 floats),\n * e.g. `\"50% 30%\"`. Returns undefined when no focal point is set.\n */\nexport function assetFocalPosition(m: MaybeAsset): string | undefined {\n  const focal = firstAsset(m)?.focal;\n  if (!focal || focal.x == null || focal.y == null) return undefined;\n  return `${(focal.x * 100).toFixed(2)}% ${(focal.y * 100).toFixed(2)}%`;\n}\n","/**\n * Runtime entry (`@arpsw/astro-cms/runtime`) — import from pages/components.\n *\n * Re-exports the CMS client + i18n helpers, and adds `resolveRequest()`: the\n * one-call request handler a site's catch-all route uses. This module reads the\n * resolved config from `virtual:arp-cms`, so it must NOT be imported from\n * `astro.config` (use the `.` entry — the integration — there).\n */\nimport { config } from './config';\nimport { CmsApiError, getMenu, resolvePath, resolvePathPreview } from './client';\nimport { resolveLocaleAndPath } from './i18n';\nimport type { Locale, Menu, Resolved } from './types';\n\nexport interface ResolveRequestOptions {\n  /** Hit the preview/draft endpoints (sets no-store + noindex). */\n  preview?: boolean;\n}\n\nexport interface ResolveRequestResult {\n  /** Active locale resolved from host/path. */\n  locale: Locale;\n  /** CMS-facing logical path (locale prefix stripped). */\n  path: string;\n  /** The resolve envelope, or null if the CMS call errored. */\n  resolved: Resolved | null;\n  /** The site nav menu (config.cms.menuSlug), or null if unavailable. */\n  menu: Menu | null;\n  /** Set when the CMS returned a redirect — the caller should `Astro.redirect`. */\n  redirect: { to: string; code: number } | null;\n  /** HTTP status that was set on the response. */\n  status: number;\n  /** Human-readable error message when the CMS call failed. */\n  error: string | null;\n}\n\ninterface RequestContext {\n  url: URL;\n  // `status` is optional to match Astro's `Astro.response` (number | undefined).\n  response: { status?: number; headers: Headers };\n}\n\n/**\n * Resolve an incoming request end-to-end: locale/path → CMS `resolve` lookup →\n * nav menu → response status + edge `Cache-Control` headers. Returns the data\n * for the route to render; on a CMS redirect it returns `redirect` for the\n * caller to `return Astro.redirect(redirect.to, redirect.code)`.\n */\nexport async function resolveRequest(\n  ctx: RequestContext,\n  options: ResolveRequestOptions = {},\n): Promise<ResolveRequestResult> {\n  const { locale, path } = resolveLocaleAndPath(ctx.url);\n\n  let resolved: Resolved | null = null;\n  let error: string | null = null;\n  let status = 200;\n\n  try {\n    resolved = options.preview\n      ? await resolvePathPreview(path, locale)\n      : await resolvePath(path, locale);\n  } catch (e) {\n    if (e instanceof CmsApiError) {\n      error = `CMS API returned ${e.status}.`;\n      status = 502;\n    } else {\n      error = e instanceof Error ? e.message : 'Unknown error.';\n      status = 500;\n    }\n  }\n\n  if (resolved?.type === 'redirect') {\n    ctx.response.headers.set('Cache-Control', config.cache.page);\n    return {\n      locale,\n      path,\n      resolved,\n      menu: null,\n      redirect: { to: resolved.to, code: resolved.code },\n      status,\n      error,\n    };\n  }\n\n  let menu: Menu | null = null;\n  try {\n    menu = await getMenu(config.cms.menuSlug, locale);\n  } catch {\n    // Non-fatal — render without a nav menu.\n  }\n\n  if (resolved?.type === 'not_found') {\n    status = 404;\n  }\n  ctx.response.status = status;\n\n  ctx.response.headers.set('Cache-Control', cacheHeaderFor(resolved, error, options.preview));\n  if (options.preview) {\n    ctx.response.headers.set('X-Robots-Tag', 'noindex, nofollow');\n  }\n\n  return { locale, path, resolved, menu, redirect: null, status, error };\n}\n\nfunction cacheHeaderFor(\n  resolved: Resolved | null,\n  error: string | null,\n  preview?: boolean,\n): string {\n  if (preview) return config.cache.preview;\n  if (error || !resolved) return config.cache.error;\n  if (resolved.type === 'page' || resolved.type === 'post') return config.cache.page;\n  if (resolved.type === 'not_found') return config.cache.notFound;\n  return config.cache.error;\n}\n\nexport { config } from './config';\nexport * from './client';\nexport * from './i18n';\nexport * from './media';\nexport type * from './types';\n"],"mappings":"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","names":[]}

package/dist/types.d.ts

@@ -0,0 +1,168 @@
+type Locale = string;
+interface MediaAsset {
+    id: number;
+    type?: string | null;
+    title?: string | null;
+    caption?: string | null;
+    /** Per-use alt (from media_asset_options.alt_text), falls back to title. */
+    alt?: string | null;
+    url: string | null;
+    thumbnail?: string | null;
+    medium?: string | null;
+    large?: string | null;
+    preview?: string | null;
+    file_name?: string | null;
+    mime_type?: string | null;
+    focal?: {
+        x: number | null;
+        y: number | null;
+    } | null;
+    [key: string]: unknown;
+}
+interface ResolvedLink {
+    url: string | null;
+    /** Target locale for internal links; null for external/manual links. */
+    locale: Locale | null;
+    /** Locale-relative logical path for internal links (the frontend builds the
+     *  real href from {locale, path}); null for external/manual links. */
+    path: string | null;
+    open_in_new_tab: boolean;
+    linkable_type: string | null;
+    linkable_id: number | null;
+}
+interface Block<T = Record<string, unknown>> {
+    type: string;
+    data: T;
+}
+interface PageMeta {
+    title: string | null;
+    description: string | null;
+    /**
+     * After BlockSerializer resolves the DAM picker shape, og_image is an array
+     * (the picker is array-based even for single-select). We accept the legacy
+     * single-object shape too for forward/backward compatibility.
+     */
+    og_image: MediaAsset | MediaAsset[] | null;
+}
+interface Page {
+    id: number;
+    slug: string;
+    locale: Locale;
+    title: string;
+    is_homepage: boolean;
+    meta: PageMeta;
+    blocks: Block[];
+    updated_at: string | null;
+}
+interface PageListItem {
+    id: number;
+    slug: string;
+    locale: Locale;
+    title: string;
+    is_homepage: boolean;
+    updated_at: string | null;
+}
+interface RedirectEnvelope {
+    redirect: {
+        to: string;
+        type: number;
+    };
+}
+interface Post {
+    id: number;
+    slug: string;
+    locale: Locale;
+    title: string;
+    excerpt: string | null;
+    body: string | null;
+    status: string;
+    published_at: string | null;
+    meta: {
+        title: string | null;
+        description: string | null;
+        og_image: MediaAsset | null;
+    };
+    featured_image: MediaAsset | null;
+    author?: {
+        name: string | null;
+        slug: string | null;
+    };
+    category?: {
+        name: string | null;
+        slug: string | null;
+    };
+}
+interface MenuItem {
+    id: number;
+    title: string;
+    type: string | null;
+    url: string | null;
+    /** Target locale for internal links; null for external/manual links. */
+    locale: Locale | null;
+    /** Locale-relative logical path for internal links; null otherwise. */
+    path: string | null;
+    open_in_new_tab: boolean;
+    is_megamenu: boolean;
+    megamenu_section: string | null;
+    cta_style: string | null;
+    children: MenuItem[];
+}
+interface Menu {
+    slug: string;
+    name: string;
+    locale: Locale;
+    items: MenuItem[];
+}
+interface WebformElement {
+    key: string | null;
+    type: string | null;
+    label: string | null;
+    help_text: string | null;
+    placeholder: string | null;
+    required: boolean;
+    max_length: number | null;
+    options: {
+        key: string;
+        label: string;
+    }[] | null;
+    content: string | null;
+    semantic_role: string | null;
+    elements?: WebformElement[];
+}
+interface Webform {
+    slug: string;
+    title: string;
+    locale: Locale;
+    elements: WebformElement[];
+    confirmation: string | null;
+}
+interface PaginatedResponse<T> {
+    data: T[];
+    links: Record<string, string | null>;
+    meta: {
+        current_page: number;
+        last_page: number;
+        per_page: number;
+        total: number;
+        [key: string]: unknown;
+    };
+}
+type ResolvedRedirect = {
+    type: 'redirect';
+    to: string;
+    code: number;
+};
+type ResolvedPage = {
+    type: 'page';
+    data: Page;
+};
+type ResolvedPost = {
+    type: 'post';
+    data: Post;
+};
+type ResolvedNotFound = {
+    type: 'not_found';
+};
+type Resolved = ResolvedRedirect | ResolvedPage | ResolvedPost | ResolvedNotFound;
+
+export type { Block, Locale, MediaAsset, Menu, MenuItem, Page, PageListItem, PageMeta, PaginatedResponse, Post, RedirectEnvelope, Resolved, ResolvedLink, ResolvedNotFound, ResolvedPage, ResolvedPost, ResolvedRedirect, Webform, WebformElement };

package/dist/types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@arpsw/astro-cms",
+  "version": "0.3.1",
+  "description": "Astro integration for the ARP (Laravel) CMS — shared API client, i18n/path resolution, and config wiring for ARP CMS sites.",
+  "type": "module",
+  "license": "UNLICENSED",
+  "author": "ARP.software",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/arpsw/astro-cms.git"
+  },
+  "keywords": [
+    "astro",
+    "astro-integration",
+    "arp",
+    "cms"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "src/components",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./runtime": {
+      "types": "./dist/runtime.d.ts",
+      "import": "./dist/runtime.js"
+    },
+    "./types": {
+      "types": "./dist/types.d.ts",
+      "import": "./dist/types.js"
+    },
+    "./CmsBlock.astro": "./src/components/CmsBlock.astro",
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "check": "tsc --noEmit",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "prepublishOnly": "npm run build"
+  },
+  "peerDependencies": {
+    "astro": "^6.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.19.19",
+    "astro": "^6.3.7",
+    "prettier": "^3.4.2",
+    "prettier-plugin-astro": "^0.14.1",
+    "tsup": "^8.3.5",
+    "typescript": "^5.9.2"
+  }
+}

package/src/components/CmsBlock.astro

@@ -0,0 +1,30 @@
+---
+/**
+ * Optional generic block dispatcher. Looks up a component for `block.type` in
+ * the `components` map and renders it, passing the whole `block` (so the
+ * component reads `block.data`) plus any extra props through. Unknown types
+ * render nothing.
+ *
+ *   import CmsBlock from '@arpsw/astro-cms/CmsBlock.astro';
+ *   import Hero from '../components/blocks/Hero.astro';
+ *   const components = { hero: Hero };
+ *   {page.blocks.map((block) => <CmsBlock {block} {components} {locale} />)}
+ *
+ * Best for sites where blocks share a uniform prop signature. Sites that want
+ * per-block typed props (or extra per-type props) should hand-write a renderer
+ * with a `block.type` switch instead.
+ */
+import type { Block } from '../types';
+
+interface Props {
+  block: Block;
+  components: Record<string, unknown>;
+}
+
+const { block, components, ...rest } = Astro.props as Props & Record<string, unknown>;
+const Component = components[block.type] as
+  | ((props: Record<string, unknown>) => unknown)
+  | undefined;
+---
+
+{Component && <Component block={block} {...rest} />}