@kdrgny/justjson-astro 1.6.0 → 1.8.0

package/README.md

@@ -97,6 +97,18 @@ export const collections = {
 Format checks (is this a real URL?) are left to `justjson validate` on purpose,
 so a typo in one entry never breaks your build in a surprising place.
 
+## Theming
+
+The generated site reads `content/_theme.json` through a small helper:
+
+```ts
+import { parseTheme, themeCss } from '@kdrgny/justjson-astro/theme'
+```
+
+`themeCss(parseTheme(theme))` returns a `:root` block of CSS variables
+(`--jj-bg`, `--jj-accent`, `--jj-font`, `--jj-radius`…). Edit the theme in the
+JustJSON **Design** tab; the site updates on the next reload.
+
 ## License
 
 [MIT](https://github.com/kdrgny-dev/justjson/blob/main/LICENSE) © Kadir Günay

package/dist/chunk-LXL6TYDO.js

@@ -0,0 +1,211 @@
+// ../core/dist/index.js
+import { z } from "zod";
+var JustJsonError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = new.target.name;
+  }
+};
+var SchemaError = class extends JustJsonError {
+};
+var fieldTypes = [
+  "text",
+  "richtext",
+  "number",
+  "boolean",
+  "date",
+  "select",
+  "relation",
+  "image",
+  "url",
+  "email",
+  "list",
+  "color",
+  "group"
+];
+var zField = z.lazy(
+  () => z.object({
+    key: z.string().min(1),
+    label: z.string().optional(),
+    type: z.enum(fieldTypes),
+    required: z.boolean().optional(),
+    options: z.array(z.string()).optional(),
+    to: z.string().optional(),
+    fields: z.array(zField).optional()
+  }).superRefine((field, ctx) => {
+    if (field.type === "select" && (!field.options || field.options.length === 0)) {
+      ctx.addIssue({ code: z.ZodIssueCode.custom, message: "a select field requires options" });
+    }
+    if (field.type === "relation" && !field.to) {
+      ctx.addIssue({ code: z.ZodIssueCode.custom, message: 'a relation field requires "to"' });
+    }
+    if (field.type === "group" && (!field.fields || field.fields.length === 0)) {
+      ctx.addIssue({ code: z.ZodIssueCode.custom, message: "a group field requires fields" });
+    }
+  })
+);
+var zCollection = z.object({
+  name: z.string().min(1),
+  label: z.string().optional(),
+  path: z.string().min(1),
+  fields: z.array(zField)
+});
+var zSingleton = z.object({
+  name: z.string().min(1),
+  label: z.string().optional(),
+  path: z.string().min(1),
+  fields: z.array(zField)
+});
+var zSchema = z.object({
+  version: z.literal(1),
+  collections: z.array(zCollection),
+  singletons: z.array(zSingleton)
+}).superRefine((schema, ctx) => {
+  const names = /* @__PURE__ */ new Set();
+  const paths = /* @__PURE__ */ new Set();
+  const collectionNames = new Set(schema.collections.map((c) => c.name));
+  const containers = [...schema.collections, ...schema.singletons];
+  for (const c of containers) {
+    if (names.has(c.name)) {
+      ctx.addIssue({ code: z.ZodIssueCode.custom, message: `duplicate name: ${c.name}` });
+    }
+    names.add(c.name);
+    if (c.path.includes("..") || c.path.startsWith("/") || c.path.includes("\\")) {
+      ctx.addIssue({ code: z.ZodIssueCode.custom, message: `unsafe path: ${c.path}` });
+    }
+    if (paths.has(c.path)) {
+      ctx.addIssue({ code: z.ZodIssueCode.custom, message: `duplicate path: ${c.path}` });
+    }
+    paths.add(c.path);
+    const keys = /* @__PURE__ */ new Set();
+    for (const f of c.fields) {
+      if (keys.has(f.key)) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: `duplicate field key: ${f.key}` });
+      }
+      keys.add(f.key);
+      if (f.type === "relation" && f.to && !collectionNames.has(f.to)) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: `relation target does not exist: ${f.to}`
+        });
+      }
+    }
+  }
+});
+function parseSchema(input) {
+  const result = zSchema.safeParse(input);
+  if (result.success) return result.data;
+  const lines = result.error.issues.map(
+    (i) => i.path.length ? `${i.path.join(".")}: ${i.message}` : i.message
+  );
+  throw new SchemaError(lines.join("\n"));
+}
+var STATUS_KEY = "_status";
+function entryStatus(data) {
+  return data[STATUS_KEY] === "draft" ? "draft" : "published";
+}
+var PALETTES = [
+  {
+    id: "paper",
+    label: "Paper",
+    bg: "#faf9f5",
+    text: "#1c1a17",
+    muted: "#6b6558",
+    border: "#e4e0d5"
+  },
+  {
+    id: "plain",
+    label: "Plain",
+    bg: "#ffffff",
+    text: "#18181b",
+    muted: "#71717a",
+    border: "#e4e4e7"
+  },
+  { id: "ink", label: "Ink", bg: "#141414", text: "#f4f4f5", muted: "#a1a1aa", border: "#2a2a2a" },
+  {
+    id: "sand",
+    label: "Sand",
+    bg: "#f5f1e8",
+    text: "#2b2620",
+    muted: "#7a7060",
+    border: "#ddd5c4"
+  },
+  { id: "sky", label: "Sky", bg: "#f7fafc", text: "#111b26", muted: "#5d7183", border: "#dbe6ef" }
+];
+var THEME_FONTS = [
+  {
+    id: "sans",
+    label: "Sans",
+    stack: 'ui-sans-serif, system-ui, -apple-system, "Segoe UI", Roboto, sans-serif'
+  },
+  { id: "serif", label: "Serif", stack: 'ui-serif, Georgia, "Times New Roman", serif' },
+  { id: "mono", label: "Mono", stack: "ui-monospace, SFMono-Regular, Menlo, monospace" },
+  {
+    id: "humanist",
+    label: "Humanist",
+    stack: '"Optima", "Gill Sans", "Trebuchet MS", ui-sans-serif, sans-serif'
+  }
+];
+var DENSITY_SCALE = {
+  tight: { gap: "0.5rem", page: "2rem", lead: "1.5" },
+  normal: { gap: "0.75rem", page: "3rem", lead: "1.65" },
+  roomy: { gap: "1.15rem", page: "4.5rem", lead: "1.8" }
+};
+var HEX = /^#([0-9a-f]{3}|[0-9a-f]{6})$/i;
+var MAX_RADIUS = 24;
+function defaultTheme() {
+  return { palette: "paper", accent: "#b8860b", font: "sans", radius: 8, density: "normal" };
+}
+function pick(list, id, fallback) {
+  return typeof id === "string" && list.some((x) => x.id === id) ? id : fallback;
+}
+function parseTheme(input) {
+  const base = defaultTheme();
+  if (typeof input !== "object" || input === null) return base;
+  const raw = input;
+  const radius = typeof raw.radius === "number" ? raw.radius : base.radius;
+  const density = raw.density;
+  return {
+    palette: pick(PALETTES, raw.palette, base.palette),
+    accent: typeof raw.accent === "string" && HEX.test(raw.accent) ? raw.accent : base.accent,
+    font: pick(THEME_FONTS, raw.font, base.font),
+    radius: Math.min(MAX_RADIUS, Math.max(0, Math.round(radius))),
+    density: density === "tight" || density === "normal" || density === "roomy" ? density : base.density
+  };
+}
+function paletteOf(theme) {
+  return PALETTES.find((p) => p.id === theme.palette) ?? PALETTES[0];
+}
+function fontOf(theme) {
+  return THEME_FONTS.find((f) => f.id === theme.font) ?? THEME_FONTS[0];
+}
+function themeCss(theme) {
+  const palette = paletteOf(theme);
+  const font = fontOf(theme);
+  const scale = DENSITY_SCALE[theme.density];
+  return [
+    ":root {",
+    `  --jj-bg: ${palette.bg};`,
+    `  --jj-text: ${palette.text};`,
+    `  --jj-muted: ${palette.muted};`,
+    `  --jj-border: ${palette.border};`,
+    `  --jj-accent: ${theme.accent};`,
+    `  --jj-font: ${font.stack};`,
+    `  --jj-radius: ${theme.radius}px;`,
+    `  --jj-gap: ${scale.gap};`,
+    `  --jj-page: ${scale.page};`,
+    `  --jj-lead: ${scale.lead};`,
+    "}"
+  ].join("\n");
+}
+
+export {
+  parseSchema,
+  STATUS_KEY,
+  entryStatus,
+  PALETTES,
+  THEME_FONTS,
+  defaultTheme,
+  parseTheme,
+  themeCss
+};

package/dist/index.js

@@ -1,144 +1,43 @@
+import {
+  STATUS_KEY,
+  entryStatus,
+  parseSchema
+} from "./chunk-LXL6TYDO.js";
+
 // src/loader.ts
 import { readFile, readdir } from "fs/promises";
 import { fileURLToPath } from "url";
 
-// ../core/dist/index.js
-import { z } from "zod";
-var JustJsonError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = new.target.name;
-  }
-};
-var SchemaError = class extends JustJsonError {
-};
-var fieldTypes = [
-  "text",
-  "richtext",
-  "number",
-  "boolean",
-  "date",
-  "select",
-  "relation",
-  "image",
-  "url",
-  "email",
-  "list",
-  "color",
-  "group"
-];
-var zField = z.lazy(
-  () => z.object({
-    key: z.string().min(1),
-    label: z.string().optional(),
-    type: z.enum(fieldTypes),
-    required: z.boolean().optional(),
-    options: z.array(z.string()).optional(),
-    to: z.string().optional(),
-    fields: z.array(zField).optional()
-  }).superRefine((field, ctx) => {
-    if (field.type === "select" && (!field.options || field.options.length === 0)) {
-      ctx.addIssue({ code: z.ZodIssueCode.custom, message: "a select field requires options" });
-    }
-    if (field.type === "relation" && !field.to) {
-      ctx.addIssue({ code: z.ZodIssueCode.custom, message: 'a relation field requires "to"' });
-    }
-    if (field.type === "group" && (!field.fields || field.fields.length === 0)) {
-      ctx.addIssue({ code: z.ZodIssueCode.custom, message: "a group field requires fields" });
-    }
-  })
-);
-var zCollection = z.object({
-  name: z.string().min(1),
-  label: z.string().optional(),
-  path: z.string().min(1),
-  fields: z.array(zField)
-});
-var zSingleton = z.object({
-  name: z.string().min(1),
-  label: z.string().optional(),
-  path: z.string().min(1),
-  fields: z.array(zField)
-});
-var zSchema = z.object({
-  version: z.literal(1),
-  collections: z.array(zCollection),
-  singletons: z.array(zSingleton)
-}).superRefine((schema, ctx) => {
-  const names = /* @__PURE__ */ new Set();
-  const paths = /* @__PURE__ */ new Set();
-  const collectionNames = new Set(schema.collections.map((c) => c.name));
-  const containers = [...schema.collections, ...schema.singletons];
-  for (const c of containers) {
-    if (names.has(c.name)) {
-      ctx.addIssue({ code: z.ZodIssueCode.custom, message: `duplicate name: ${c.name}` });
-    }
-    names.add(c.name);
-    if (c.path.includes("..") || c.path.startsWith("/") || c.path.includes("\\")) {
-      ctx.addIssue({ code: z.ZodIssueCode.custom, message: `unsafe path: ${c.path}` });
-    }
-    if (paths.has(c.path)) {
-      ctx.addIssue({ code: z.ZodIssueCode.custom, message: `duplicate path: ${c.path}` });
-    }
-    paths.add(c.path);
-    const keys = /* @__PURE__ */ new Set();
-    for (const f of c.fields) {
-      if (keys.has(f.key)) {
-        ctx.addIssue({ code: z.ZodIssueCode.custom, message: `duplicate field key: ${f.key}` });
-      }
-      keys.add(f.key);
-      if (f.type === "relation" && f.to && !collectionNames.has(f.to)) {
-        ctx.addIssue({
-          code: z.ZodIssueCode.custom,
-          message: `relation target does not exist: ${f.to}`
-        });
-      }
-    }
-  }
-});
-function parseSchema(input) {
-  const result = zSchema.safeParse(input);
-  if (result.success) return result.data;
-  const lines = result.error.issues.map(
-    (i) => i.path.length ? `${i.path.join(".")}: ${i.message}` : i.message
-  );
-  throw new SchemaError(lines.join("\n"));
-}
-var STATUS_KEY = "_status";
-function entryStatus(data) {
-  return data[STATUS_KEY] === "draft" ? "draft" : "published";
-}
-
 // src/zod-schema.ts
-import { z as z2 } from "zod";
+import { z } from "zod";
 function base(field) {
   switch (field.type) {
     case "number":
-      return z2.number();
+      return z.number();
     case "boolean":
-      return z2.boolean();
+      return z.boolean();
     case "relation":
     case "list":
-      return z2.array(z2.string());
+      return z.array(z.string());
     case "group":
       return fieldsToZod(field.fields ?? []);
     case "select": {
       const options = field.options ?? [];
-      return options.length > 0 ? z2.enum(options) : z2.string();
+      return options.length > 0 ? z.enum(options) : z.string();
     }
     default:
-      return z2.string();
+      return z.string();
   }
 }
 function fieldsToZod(fields) {
   const shape = {
-    [STATUS_KEY]: z2.enum(["draft", "published"]).optional()
+    [STATUS_KEY]: z.enum(["draft", "published"]).optional()
   };
   for (const field of fields) {
     const type = base(field);
     shape[field.key] = field.required ? type : type.optional();
   }
-  return z2.object(shape);
+  return z.object(shape);
 }
 
 // src/loader.ts

package/dist/theme.d.ts

@@ -0,0 +1 @@
+export { Density, PALETTES, Palette, THEME_FONTS, Theme, ThemeFont, defaultTheme, parseTheme, themeCss } from '@justjson/core';

package/dist/theme.js

@@ -0,0 +1,14 @@
+import {
+  PALETTES,
+  THEME_FONTS,
+  defaultTheme,
+  parseTheme,
+  themeCss
+} from "./chunk-LXL6TYDO.js";
+export {
+  PALETTES,
+  THEME_FONTS,
+  defaultTheme,
+  parseTheme,
+  themeCss
+};

package/package.json

@@ -1,29 +1,43 @@
 {
   "name": "@kdrgny/justjson-astro",
-  "version": "1.6.0",
-  "description": "Astro content loader for JustJSON — turn your content/ folder into typed Astro content collections.",
+  "version": "1.8.0",
+  "description": "Astro content loader for JustJSON \u2014 turn your content/ folder into typed Astro content collections.",
   "type": "module",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
   },
-  "author": "Kadir Günay",
+  "author": "Kadir G\u00fcnay",
   "homepage": "https://github.com/kdrgny-dev/justjson",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/kdrgny-dev/justjson.git",
     "directory": "packages/astro"
   },
-  "keywords": ["astro", "astro-loader", "astro-integration", "cms", "json", "content", "justjson"],
+  "keywords": [
+    "astro",
+    "astro-loader",
+    "astro-integration",
+    "cms",
+    "json",
+    "content",
+    "justjson"
+  ],
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
+    },
+    "./theme": {
+      "types": "./dist/theme.d.ts",
+      "import": "./dist/theme.js"
     }
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "files": ["dist"],
+  "files": [
+    "dist"
+  ],
   "scripts": {
     "build": "tsup",
     "dev": "tsup --watch",