ampless 0.2.0-alpha.0

package/dist/index.js

@@ -0,0 +1,463 @@
+// src/config.ts
+function defineConfig(config) {
+  return config;
+}
+
+// src/schema.ts
+function defineSchema(schema) {
+  return schema;
+}
+
+// src/dummy.ts
+var DUMMY_POSTS = [
+  {
+    postId: "post-001",
+    siteId: "default",
+    slug: "hello-world",
+    title: "Hello, ampless",
+    excerpt: "Welcome to your new ampless-powered blog. This is the first post.",
+    format: "markdown",
+    body: "# Hello, ampless\n\nWelcome to your new blog powered by **ampless** \u2014 a serverless CMS for AWS Amplify.\n\nThis post is served from the built-in dummy content. Once you run `npx ampx sandbox` and create posts from the admin panel, they will replace this placeholder.\n\n## What to try next\n\n- Edit `cms.config.ts` to customize your site\n- Run `npx ampx sandbox` to deploy the backend\n- Visit `/admin` to manage content (coming in Phase 4)\n",
+    status: "published",
+    publishedAt: "2026-04-01T00:00:00Z",
+    tags: ["welcome"]
+  },
+  {
+    postId: "post-002",
+    siteId: "default",
+    slug: "about-ampless",
+    title: "About ampless",
+    excerpt: "Why ampless exists, and what makes it different from other CMS options.",
+    format: "markdown",
+    body: '# About ampless\n\nampless is an open-source CMS built natively for AWS Amplify \u2014 the "EmDash for AWS" position.\n\n## Key differences\n\n- **AWS-native**: Uses Amplify Gen 2, DynamoDB, S3, Cognito, Lambda\n- **Plugin-first**: Core stays small, features come from plugins\n- **AI-first**: MCP Server included from v0.1\n- **MIT licensed**: No commercial barriers\n',
+    status: "published",
+    publishedAt: "2026-04-02T00:00:00Z",
+    tags: ["meta"]
+  },
+  {
+    postId: "post-003",
+    siteId: "default",
+    slug: "getting-started",
+    title: "Getting started",
+    excerpt: "How to set up your ampless site and deploy it to AWS.",
+    format: "markdown",
+    body: "# Getting started\n\n## Local development\n\n```bash\nnpm install\nnpm run dev\n```\n\n## Deploy to AWS\n\n```bash\nnpx ampx sandbox   # personal sandbox\n# or push to git and connect to Amplify Hosting\n```\n",
+    status: "published",
+    publishedAt: "2026-04-03T00:00:00Z",
+    tags: ["docs"]
+  }
+];
+
+// src/core.ts
+var provider = null;
+function setPostsProvider(p) {
+  provider = p;
+}
+function hasPostsProvider() {
+  return provider !== null;
+}
+function dummyList(opts = {}) {
+  const { siteId = "default", limit, status = "published" } = opts;
+  let posts = DUMMY_POSTS.filter((p) => p.siteId === siteId);
+  if (status !== "all") posts = posts.filter((p) => p.status === status);
+  return limit ? posts.slice(0, limit) : posts;
+}
+async function listPosts(opts = {}) {
+  if (provider) return provider.list(opts);
+  return dummyList(opts);
+}
+async function getPost(slug, opts = {}) {
+  if (provider) return provider.get(slug, opts);
+  const { siteId = "default" } = opts;
+  return DUMMY_POSTS.find((p) => p.siteId === siteId && p.slug === slug) ?? null;
+}
+async function getPostById(postId, opts = {}) {
+  if (provider) return provider.getById(postId, opts);
+  const { siteId = "default" } = opts;
+  return DUMMY_POSTS.find((p) => p.siteId === siteId && p.postId === postId) ?? null;
+}
+async function createPost(data) {
+  if (!provider) throw new Error("No posts provider configured. Call setPostsProvider() first.");
+  return provider.create(data);
+}
+async function updatePost(postId, data, opts = {}) {
+  if (!provider) throw new Error("No posts provider configured. Call setPostsProvider() first.");
+  return provider.update(postId, data, opts);
+}
+async function deletePost(postId, opts = {}) {
+  if (!provider) throw new Error("No posts provider configured. Call setPostsProvider() first.");
+  return provider.remove(postId, opts);
+}
+
+// src/sites.ts
+var DEFAULT_SITE_ID = "default";
+function resolveSiteId(host, config) {
+  const sites = config.sites;
+  if (!sites || Object.keys(sites).length === 0) {
+    return DEFAULT_SITE_ID;
+  }
+  const lower = host.toLowerCase();
+  for (const [id, site] of Object.entries(sites)) {
+    if (site.domains.some((d) => d.toLowerCase() === lower)) return id;
+  }
+  return null;
+}
+function isMultiSite(config) {
+  return !!config.sites && Object.keys(config.sites).length >= 2;
+}
+function siteFor(siteId, config) {
+  const override = config.sites?.[siteId];
+  return {
+    name: override?.name ?? config.site.name,
+    url: override?.url ?? config.site.url,
+    description: override?.description ?? config.site.description
+  };
+}
+function composeSiteIdStatus(siteId, status) {
+  return `${siteId}#${status}`;
+}
+function composeSiteIdSlug(siteId, slug) {
+  return `${siteId}#${slug}`;
+}
+
+// src/kv.ts
+var store = null;
+function setKvStore(s) {
+  store = s;
+}
+function hasKvStore() {
+  return store !== null;
+}
+function requireStore() {
+  if (!store) {
+    throw new Error("No KvStore configured. Call setKvStore() during initialization.");
+  }
+  return store;
+}
+var SITE_CONFIG_PK = (siteId) => `siteconfig:${siteId}`;
+async function getSiteSetting(siteId, key) {
+  return requireStore().get(SITE_CONFIG_PK(siteId), key);
+}
+async function setSiteSetting(siteId, key, value) {
+  return requireStore().put(SITE_CONFIG_PK(siteId), key, value);
+}
+async function deleteSiteSetting(siteId, key) {
+  return requireStore().remove(SITE_CONFIG_PK(siteId), key);
+}
+async function listSiteSettings(siteId = DEFAULT_SITE_ID) {
+  const items = await requireStore().query(SITE_CONFIG_PK(siteId));
+  const out = {};
+  for (const item of items) {
+    out[item.sk] = item.value;
+  }
+  return out;
+}
+function flattenSettings(obj, prefix = "") {
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) {
+    const path = prefix ? `${prefix}.${k}` : k;
+    if (v !== null && typeof v === "object" && !Array.isArray(v)) {
+      Object.assign(out, flattenSettings(v, path));
+    } else {
+      out[path] = v;
+    }
+  }
+  return out;
+}
+function unflattenSettings(flat) {
+  const out = {};
+  for (const [path, value] of Object.entries(flat)) {
+    const parts = path.split(".");
+    let cursor = out;
+    for (let i = 0; i < parts.length - 1; i++) {
+      const part = parts[i];
+      const existing = cursor[part];
+      if (existing === void 0 || typeof existing !== "object" || existing === null) {
+        cursor[part] = {};
+      }
+      cursor = cursor[part];
+    }
+    cursor[parts[parts.length - 1]] = value;
+  }
+  return out;
+}
+
+// src/format.ts
+function formatDate(input, format = "iso", timezone = "UTC") {
+  const d = input instanceof Date ? input : new Date(input);
+  if (Number.isNaN(d.getTime())) return "";
+  switch (format) {
+    case "iso":
+      return isoInTimezone(d, timezone);
+    case "long":
+      return new Intl.DateTimeFormat("en-US", {
+        year: "numeric",
+        month: "long",
+        day: "numeric",
+        timeZone: timezone
+      }).format(d);
+    case "locale":
+      return new Intl.DateTimeFormat(void 0, { timeZone: timezone }).format(d);
+    default:
+      return d.toISOString();
+  }
+}
+function isoInTimezone(d, timezone) {
+  const parts = new Intl.DateTimeFormat("en-US", {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    timeZone: timezone
+  }).formatToParts(d);
+  const year = parts.find((p) => p.type === "year")?.value ?? "0000";
+  const month = parts.find((p) => p.type === "month")?.value ?? "00";
+  const day = parts.find((p) => p.type === "day")?.value ?? "00";
+  return `${year}-${month}-${day}`;
+}
+
+// src/xml.ts
+var XML_ESCAPES = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  // Use numeric reference for the apostrophe — &apos; is XML 1.0 only and
+  // a few legacy RSS validators reject it. &#39; is universal.
+  "'": "&#39;"
+};
+function escapeXml(s) {
+  return s.replace(/[&<>"']/g, (c) => XML_ESCAPES[c]);
+}
+
+// src/storage.ts
+function formatPublicAssetUrl(bucket, region, key) {
+  return `https://${bucket}.s3.${region}.amazonaws.com/${key}`;
+}
+
+// src/plugin.ts
+function definePlugin(p) {
+  return p;
+}
+
+// src/post-images.ts
+function extractFirstImageUrl(post) {
+  switch (post.format) {
+    case "tiptap":
+      return findTiptapImage(post.body);
+    case "markdown":
+      return findMarkdownImage(post.body);
+    case "html":
+      return findHtmlImage(post.body);
+    default:
+      return null;
+  }
+}
+function findTiptapImage(body) {
+  if (!body || typeof body !== "object") return null;
+  const node = body;
+  if (node.type === "image") {
+    const src = node.attrs?.src;
+    if (typeof src === "string" && src.length > 0) return src;
+  }
+  if (Array.isArray(node.content)) {
+    for (const child of node.content) {
+      const hit = findTiptapImage(child);
+      if (hit) return hit;
+    }
+  }
+  return null;
+}
+function findMarkdownImage(body) {
+  if (typeof body !== "string") return null;
+  const m = body.match(/!\[[^\]]*\]\(([^)]+)\)/);
+  return m ? m[1] : null;
+}
+function findHtmlImage(body) {
+  if (typeof body !== "string") return null;
+  const m = body.match(/<img[^>]+src=["']([^"']+)["']/i);
+  return m ? m[1] : null;
+}
+
+// src/events.ts
+function detectContentEvents(input) {
+  switch (input.eventName) {
+    case "INSERT": {
+      const out = ["content.created"];
+      if (input.newStatus === "published") out.push("content.published");
+      return out;
+    }
+    case "MODIFY": {
+      const wasPublished = input.oldStatus === "published";
+      const isPublished = input.newStatus === "published";
+      const out = ["content.updated"];
+      if (!wasPublished && isPublished) out.push("content.published");
+      else if (wasPublished && !isPublished) out.push("content.unpublished");
+      return out;
+    }
+    case "REMOVE": {
+      const out = [];
+      if (input.oldStatus === "published") out.push("content.unpublished");
+      out.push("content.deleted");
+      return out;
+    }
+    default:
+      return [];
+  }
+}
+
+// src/theme.ts
+function defineTheme(m) {
+  return m;
+}
+function resolveLocalized(value, locale, fallback = "en") {
+  if (value === void 0) return "";
+  if (typeof value === "string") return value;
+  return value[locale] ?? value[fallback] ?? Object.values(value)[0] ?? "";
+}
+function defineThemeModule(m) {
+  return m;
+}
+function themeSettingKey(fieldKey) {
+  return `theme.${fieldKey}`;
+}
+var COLOR_RE = /^(#[0-9a-fA-F]{3,8}|rgb\([^)]+\)|rgba\([^)]+\)|hsl\([^)]+\)|hsla\([^)]+\)|oklch\([^)]+\)|oklab\([^)]+\))$/;
+var LENGTH_RE = /^[\d.]+(px|rem|em|%|vh|vw)$/;
+var DANGEROUS_IMAGE_URL_RE = /^\s*(javascript|vbscript):/i;
+function validateThemeValue(field, raw) {
+  if (field.type === "linkList") return validateLinkListValue(field, raw);
+  if (typeof raw !== "string") return null;
+  const v = raw.trim();
+  if (!v) return null;
+  switch (field.type) {
+    case "color":
+      return COLOR_RE.test(v) ? v : null;
+    case "length":
+      return LENGTH_RE.test(v) ? v : null;
+    case "image":
+      return DANGEROUS_IMAGE_URL_RE.test(v) ? null : v;
+    case "select":
+    case "fontFamily":
+      return field.options.some((o) => o.value === v) ? v : null;
+    case "text": {
+      const max = field.maxLength ?? 200;
+      const sanitized = v.replace(/[\x00-\x1f<>]/g, "");
+      return sanitized.length <= max ? sanitized : sanitized.slice(0, max);
+    }
+  }
+}
+var DANGEROUS_URL_RE = /^\s*(javascript|data|vbscript):/i;
+function validateLinkListValue(field, raw) {
+  let parsed;
+  if (Array.isArray(raw)) {
+    parsed = raw;
+  } else if (typeof raw === "string") {
+    const trimmed = raw.trim();
+    if (!trimmed) return JSON.stringify([]);
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      return null;
+    }
+  } else if (raw === null || raw === void 0) {
+    return JSON.stringify([]);
+  } else {
+    return null;
+  }
+  if (!Array.isArray(parsed)) return null;
+  const max = field.maxItems ?? 50;
+  if (parsed.length > max) return null;
+  const cleaned = [];
+  for (const entry of parsed) {
+    if (!entry || typeof entry !== "object") continue;
+    const e = entry;
+    const rawLabel = typeof e.label === "string" ? e.label : "";
+    const rawUrl = typeof e.url === "string" ? e.url : "";
+    const label = rawLabel.replace(/[\x00-\x1f<>]/g, "").trim().slice(0, 120);
+    const url = rawUrl.replace(/[\x00-\x1f]/g, "").trim().slice(0, 500);
+    if (!label && !url) continue;
+    if (url && DANGEROUS_URL_RE.test(url)) continue;
+    cleaned.push({ label, url });
+  }
+  return JSON.stringify(cleaned);
+}
+function parseLinkList(raw) {
+  if (!raw) return [];
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter(
+      (e) => !!e && typeof e === "object" && typeof e.label === "string" && typeof e.url === "string"
+    ).map((e) => ({ label: e.label, url: e.url }));
+  } catch {
+    return [];
+  }
+}
+function stringifyLinkList(items) {
+  return JSON.stringify(items.map((i) => ({ label: i.label, url: i.url })));
+}
+function isTagListUrl(url) {
+  const m = /^tag:(.+)$/.exec(url.trim());
+  if (!m) return null;
+  const tag = m[1].trim();
+  return tag ? { tag } : null;
+}
+function resolveThemeValues(manifest, stored) {
+  const out = {};
+  for (const field of manifest.fields) {
+    const storeKey = themeSettingKey(field.key);
+    const raw = stored[storeKey];
+    const validated = raw !== void 0 ? validateThemeValue(field, raw) : null;
+    out[field.key] = validated ?? defaultValueAsString(field);
+  }
+  return out;
+}
+function defaultValueAsString(field) {
+  if (field.type === "linkList") return stringifyLinkList(field.default);
+  return field.default;
+}
+
+// src/index.ts
+var VERSION = "0.0.1";
+export {
+  DEFAULT_SITE_ID,
+  SITE_CONFIG_PK,
+  VERSION,
+  composeSiteIdSlug,
+  composeSiteIdStatus,
+  createPost,
+  defineConfig,
+  definePlugin,
+  defineSchema,
+  defineTheme,
+  defineThemeModule,
+  deletePost,
+  deleteSiteSetting,
+  detectContentEvents,
+  escapeXml,
+  extractFirstImageUrl,
+  flattenSettings,
+  formatDate,
+  formatPublicAssetUrl,
+  getPost,
+  getPostById,
+  getSiteSetting,
+  hasKvStore,
+  hasPostsProvider,
+  isMultiSite,
+  isTagListUrl,
+  listPosts,
+  listSiteSettings,
+  parseLinkList,
+  resolveLocalized,
+  resolveSiteId,
+  resolveThemeValues,
+  setKvStore,
+  setPostsProvider,
+  setSiteSetting,
+  siteFor,
+  stringifyLinkList,
+  themeSettingKey,
+  unflattenSettings,
+  updatePost,
+  validateThemeValue
+};

package/dist/media/index.d.ts

@@ -0,0 +1,48 @@
+type OutputFormat = 'webp' | 'jpeg' | 'original';
+interface CropArea {
+    /** Source-pixel coordinates of the crop rectangle. */
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface ProcessOptions {
+    /** Skip all processing and return the input file as-is. */
+    original?: boolean;
+    /** Crop rectangle in source pixels. Omit for no crop. */
+    crop?: CropArea;
+    /** Clamp the longer edge to this many pixels. Never upscales. */
+    maxDimension?: number;
+    /** Output container. `'original'` keeps the input mime. */
+    format?: OutputFormat;
+    /** Lossy quality 0..1. Ignored for lossless WebP and PNG. Defaults to 0.85. */
+    quality?: number;
+    /** Force lossless WebP encoding. Only meaningful when format === 'webp'. */
+    lossless?: boolean;
+}
+interface ProcessedImage {
+    blob: Blob;
+    mime: string;
+    /** Decoded width in pixels. 0 means the dimensions could not be determined (e.g. SVG, undecodable passthrough). */
+    width: number;
+    /** Decoded height in pixels. 0 means the dimensions could not be determined (e.g. SVG, undecodable passthrough). */
+    height: number;
+    /** Filename derived from the input, with the extension matching `mime`. */
+    suggestedName: string;
+}
+declare function shouldSkipProcessing(mime: string): boolean;
+declare function extensionFor(mime: string): string;
+declare function replaceExtension(name: string, mime: string): string;
+declare function resolveOutputMime(inputMime: string, format: OutputFormat | undefined): string;
+interface TargetDimensions {
+    width: number;
+    height: number;
+}
+/**
+ * Resolve target dimensions, honouring caller's maxDimension AND the hard
+ * canvas-budget ceiling. Never upscales the source.
+ */
+declare function computeTargetDimensions(sourceWidth: number, sourceHeight: number, maxDimension: number | undefined): TargetDimensions;
+declare function processImage(file: File, options?: ProcessOptions): Promise<ProcessedImage>;
+
+export { type CropArea, type OutputFormat, type ProcessOptions, type ProcessedImage, type TargetDimensions, computeTargetDimensions, extensionFor, processImage, replaceExtension, resolveOutputMime, shouldSkipProcessing };

package/dist/media/index.js

@@ -0,0 +1,174 @@
+// src/media/processing.ts
+var HARD_MAX_DIMENSION = 8e3;
+var PASSTHROUGH_MIMES = /* @__PURE__ */ new Set([
+  "image/gif",
+  // animated frames would be lost via Canvas
+  "image/svg+xml",
+  // raster encoding destroys vectors
+  "image/avif",
+  // re-encoding cost > benefit for now
+  "image/heic",
+  // iPhone default; most browsers cannot decode at all
+  "image/heif",
+  "image/bmp",
+  // Canvas decode is patchy
+  "image/tiff"
+]);
+function shouldSkipProcessing(mime) {
+  if (!mime || !mime.startsWith("image/")) return true;
+  return PASSTHROUGH_MIMES.has(mime);
+}
+var MIME_TO_EXT = {
+  "image/webp": "webp",
+  "image/jpeg": "jpg",
+  "image/png": "png",
+  "image/gif": "gif",
+  "image/svg+xml": "svg",
+  "image/avif": "avif",
+  "image/heic": "heic",
+  "image/heif": "heif",
+  "image/bmp": "bmp",
+  "image/tiff": "tif"
+};
+function extensionFor(mime) {
+  return MIME_TO_EXT[mime] ?? "bin";
+}
+function replaceExtension(name, mime) {
+  const ext = extensionFor(mime);
+  const i = name.lastIndexOf(".");
+  const base = i > 0 ? name.slice(0, i) : name;
+  return `${base}.${ext}`;
+}
+function resolveOutputMime(inputMime, format) {
+  if (format === "webp") return "image/webp";
+  if (format === "jpeg") return "image/jpeg";
+  return inputMime || "application/octet-stream";
+}
+function computeTargetDimensions(sourceWidth, sourceHeight, maxDimension) {
+  const longer = Math.max(sourceWidth, sourceHeight);
+  const requested = maxDimension && maxDimension > 0 ? maxDimension : longer;
+  const effective = Math.min(requested, HARD_MAX_DIMENSION);
+  if (longer <= effective) {
+    return { width: sourceWidth, height: sourceHeight };
+  }
+  const scale = effective / longer;
+  return {
+    width: Math.max(1, Math.round(sourceWidth * scale)),
+    height: Math.max(1, Math.round(sourceHeight * scale))
+  };
+}
+async function processImage(file, options = {}) {
+  if (options.original || shouldSkipProcessing(file.type)) {
+    return passthrough(file);
+  }
+  let bitmap;
+  try {
+    bitmap = await createImageBitmap(file);
+  } catch {
+    return passthrough(file);
+  }
+  try {
+    const source = options.crop ?? {
+      x: 0,
+      y: 0,
+      width: bitmap.width,
+      height: bitmap.height
+    };
+    const target = computeTargetDimensions(source.width, source.height, options.maxDimension);
+    const canvas = createCanvas(target.width, target.height);
+    const ctx = canvas.getContext("2d");
+    if (!ctx) throw new Error("Failed to obtain 2D rendering context");
+    ctx.drawImage(
+      bitmap,
+      source.x,
+      source.y,
+      source.width,
+      source.height,
+      0,
+      0,
+      target.width,
+      target.height
+    );
+    const outMime = resolveOutputMime(file.type, options.format);
+    const quality = options.quality ?? 0.85;
+    const wantsLossless = outMime === "image/webp" && options.lossless === true;
+    let blob;
+    if (wantsLossless) {
+      try {
+        blob = await encodeWebpLossless(ctx, target.width, target.height);
+      } catch {
+        blob = await canvasToBlob(canvas, "image/webp", 0.95);
+      }
+    } else {
+      blob = await canvasToBlob(canvas, outMime, quality);
+    }
+    return {
+      blob,
+      mime: blob.type || outMime,
+      width: target.width,
+      height: target.height,
+      suggestedName: replaceExtension(file.name, blob.type || outMime)
+    };
+  } finally {
+    bitmap.close?.();
+  }
+}
+async function passthrough(file) {
+  let width = 0;
+  let height = 0;
+  if (typeof createImageBitmap !== "undefined" && file.type !== "image/svg+xml") {
+    try {
+      const bm = await createImageBitmap(file);
+      width = bm.width;
+      height = bm.height;
+      bm.close?.();
+    } catch {
+    }
+  }
+  return {
+    blob: file,
+    mime: file.type || "application/octet-stream",
+    width,
+    height,
+    suggestedName: file.name
+  };
+}
+function createCanvas(width, height) {
+  const hasOffscreenEncode = typeof OffscreenCanvas !== "undefined" && typeof OffscreenCanvas.prototype !== "undefined" && "convertToBlob" in OffscreenCanvas.prototype;
+  if (hasOffscreenEncode) {
+    return new OffscreenCanvas(width, height);
+  }
+  if (typeof document !== "undefined") {
+    const c = document.createElement("canvas");
+    c.width = width;
+    c.height = height;
+    return c;
+  }
+  throw new Error("No canvas implementation available in this environment");
+}
+async function canvasToBlob(canvas, type, quality) {
+  if ("convertToBlob" in canvas) {
+    return canvas.convertToBlob({ type, quality });
+  }
+  return new Promise((resolve, reject) => {
+    canvas.toBlob(
+      (blob) => blob ? resolve(blob) : reject(new Error(`canvas.toBlob returned null for ${type}`)),
+      type,
+      quality
+    );
+  });
+}
+async function encodeWebpLossless(ctx, width, height) {
+  const imageData = ctx.getImageData(0, 0, width, height);
+  const mod = await import("@jsquash/webp");
+  const buffer = await mod.encode(imageData, { lossless: 1 });
+  return new Blob([buffer], { type: "image/webp" });
+}
+export {
+  computeTargetDimensions,
+  extensionFor,
+  processImage,
+  replaceExtension,
+  resolveOutputMime,
+  shouldSkipProcessing
+};