@drawnagency/primitives 0.1.0 → 0.2.0

package/dist/chunk-IP6ODLXX.js

@@ -0,0 +1,341 @@
+// src/media/utils.ts
+async function hashFileBuffer(buffer) {
+  if (typeof crypto !== "undefined" && crypto.subtle) {
+    const hashBuffer = await crypto.subtle.digest("SHA-256", buffer);
+    const hashArray = new Uint8Array(hashBuffer);
+    return Array.from(hashArray.slice(0, 8)).map((b) => b.toString(16).padStart(2, "0")).join("");
+  }
+  const bytes = new Uint8Array(buffer);
+  const seeds = [2166136261, 84696351];
+  let result = "";
+  for (const seed of seeds) {
+    let h = seed;
+    for (let i = 0; i < bytes.length; i++) {
+      h ^= bytes[i];
+      h = Math.imul(h, 16777619);
+    }
+    result += (h >>> 0).toString(16).padStart(8, "0");
+  }
+  return result;
+}
+function sanitizeMediaName(name) {
+  return name.replace(/\.[^.]+$/, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+var MIME_TO_EXT = {
+  "image/gif": "gif",
+  "image/apng": "apng",
+  "image/png": "png",
+  "image/jpeg": "jpg",
+  "image/webp": "webp",
+  "image/svg+xml": "svg",
+  "video/mp4": "mp4",
+  "video/webm": "webm"
+};
+var EXT_TO_MIME = {
+  ...Object.fromEntries(
+    Object.entries(MIME_TO_EXT).map(([mime, ext]) => [`.${ext}`, mime])
+  ),
+  ".jpeg": "image/jpeg"
+};
+function mimeToExt(mime) {
+  return MIME_TO_EXT[mime] ?? "bin";
+}
+function displayFilenameExt(mime) {
+  const ext = MIME_TO_EXT[mime];
+  return ext ? `.${ext}` : "";
+}
+
+// src/media/github.ts
+function createGitHubMediaAdapter(manifest) {
+  return {
+    async hash(file) {
+      return hashFileBuffer(file.buffer);
+    },
+    async exists(hash) {
+      return hash in manifest.images;
+    },
+    async process(file, hash, _sizes) {
+      const name = sanitizeMediaName(file.originalName);
+      const folder = `${name}-${hash}`;
+      return {
+        id: hash,
+        hash,
+        kind: "image",
+        originalName: name,
+        width: 0,
+        height: 0,
+        mimeType: "image/webp",
+        size: 0,
+        folder,
+        variants: [],
+        alt: ""
+      };
+    },
+    async delete(id) {
+      delete manifest.images[id];
+    },
+    resolve(id, sizes) {
+      const item = manifest.images[id];
+      if (!item) return null;
+      if (item.kind === "video") {
+        return {
+          tag: "video",
+          src: `/api/media/${id}/original.${mimeToExt(item.mimeType)}`,
+          poster: `/api/media/${id}/poster.webp`,
+          width: item.width,
+          height: item.height,
+          autoplay: true,
+          loop: true,
+          muted: true
+        };
+      }
+      if (item.kind === "animated") {
+        return {
+          tag: "img",
+          src: `/api/media/${id}/original.${mimeToExt(item.mimeType)}`,
+          width: item.width,
+          height: item.height
+        };
+      }
+      const availableVariants = item.variants.filter(
+        (v) => sizes.length === 0 || sizes.includes(v.width)
+      );
+      const sorted = [...availableVariants].sort((a, b) => a.width - b.width);
+      const midIndex = Math.floor(sorted.length / 2);
+      const defaultVariant = sorted[midIndex] ?? sorted[0];
+      if (!defaultVariant) return null;
+      const srcSet = sorted.map((v) => `/api/media/${id}/${v.width}.webp ${v.width}w`).join(", ");
+      return {
+        tag: "img",
+        src: `/api/media/${id}/${defaultVariant.width}.webp`,
+        srcSet,
+        width: item.width,
+        height: item.height
+      };
+    },
+    async list() {
+      return Object.values(manifest.images);
+    }
+  };
+}
+
+// src/media/queue.ts
+var ProcessingQueue = class {
+  items = /* @__PURE__ */ new Map();
+  pending = [];
+  activeWorkers = /* @__PURE__ */ new Map();
+  options;
+  nextId = 0;
+  constructor(options) {
+    this.options = options;
+  }
+  add(input) {
+    const id = `media-${this.nextId++}`;
+    const item = {
+      id,
+      originalName: input.originalName,
+      mimeType: input.mimeType,
+      hash: input.hash,
+      kind: input.kind,
+      percent: 0,
+      state: "queued"
+    };
+    this.items.set(id, item);
+    this.pending.push({ input, id });
+    this.options.onEvent({ type: "queued", item: { ...item } });
+    this.processNext();
+    return id;
+  }
+  getStatus() {
+    let active = 0;
+    let queued = 0;
+    for (const item of this.items.values()) {
+      if (item.state === "active") active++;
+      if (item.state === "queued") queued++;
+    }
+    return {
+      active,
+      queued,
+      total: this.items.size,
+      items: Array.from(this.items.values())
+    };
+  }
+  processNext() {
+    while (this.activeWorkers.size < this.options.maxConcurrent && this.pending.length > 0) {
+      const next = this.pending.shift();
+      this.startProcessing(next.id, next.input);
+    }
+  }
+  startProcessing(id, input) {
+    const item = this.items.get(id);
+    item.state = "active";
+    this.options.onEvent({ type: "started", item: { ...item } });
+    const worker = this.options.createWorker();
+    this.activeWorkers.set(id, worker);
+    worker.onmessage = (e) => {
+      const msg = e.data;
+      if (msg.id !== id) return;
+      if (msg.type === "progress") {
+        item.percent = msg.percent;
+        this.options.onEvent({ type: "progress", item: { ...item } });
+      } else if (msg.type === "complete") {
+        item.state = "complete";
+        item.percent = 100;
+        item.result = {
+          variants: msg.variants,
+          primaryBlob: msg.primaryBlob,
+          posterBlob: msg.posterBlob,
+          width: msg.width,
+          height: msg.height
+        };
+        this.options.onEvent({ type: "complete", item: { ...item } });
+        this.cleanupWorker(id, worker);
+        this.processNext();
+      } else if (msg.type === "error") {
+        item.state = "error";
+        item.error = msg.message;
+        this.options.onEvent({ type: "error", item: { ...item } });
+        this.cleanupWorker(id, worker);
+        this.processNext();
+      }
+    };
+    worker.onerror = (e) => {
+      item.state = "error";
+      item.error = e.message || "Worker error";
+      this.options.onEvent({ type: "error", item: { ...item } });
+      this.cleanupWorker(id, worker);
+      this.processNext();
+    };
+    worker.postMessage({
+      type: "process",
+      id,
+      buffer: input.buffer,
+      originalName: input.originalName,
+      mimeType: input.mimeType,
+      hash: input.hash,
+      kind: input.kind,
+      sizes: this.options.sizes,
+      quality: this.options.quality
+    });
+  }
+  cleanupWorker(id, worker) {
+    worker.terminate();
+    this.activeWorkers.delete(id);
+  }
+  destroy() {
+    for (const [id, worker] of this.activeWorkers) {
+      worker.terminate();
+      this.activeWorkers.delete(id);
+    }
+    this.pending = [];
+    this.items.clear();
+  }
+};
+
+// src/media/resolve.ts
+function resolveMedia(item, manifest, sizes) {
+  if (!item.imageId) return null;
+  const adapter = createMediaAdapter(manifest);
+  return adapter.resolve(item.imageId, sizes);
+}
+function resolveManifestReferences(content, manifest, sizes) {
+  if (Array.isArray(content)) {
+    return content.map((item) => resolveManifestReferences(item, manifest, sizes));
+  }
+  if (content !== null && typeof content === "object") {
+    const obj = content;
+    if (typeof obj.imageId === "string") {
+      const manifestItem = manifest.images[obj.imageId];
+      const resolved = resolveMedia({ imageId: obj.imageId }, manifest, sizes);
+      const patch = {
+        alt: manifestItem?.alt ?? ""
+      };
+      if (resolved && resolved.tag === "img") {
+        patch.src = resolved.src;
+        if ("srcSet" in resolved && resolved.srcSet) {
+          patch.srcset = resolved.srcSet;
+        }
+      } else if (resolved && resolved.tag === "video") {
+        patch.src = resolved.src;
+        if (resolved.poster) {
+          patch.poster = resolved.poster;
+        }
+      }
+      return { ...obj, ...patch };
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = resolveManifestReferences(value, manifest, sizes);
+    }
+    return result;
+  }
+  return content;
+}
+
+// src/media/videoPoster.ts
+function generateVideoPoster(blob, quality) {
+  return new Promise((resolve, reject) => {
+    const video = document.createElement("video");
+    const url = URL.createObjectURL(blob);
+    video.muted = true;
+    video.preload = "auto";
+    video.src = url;
+    const cleanup = () => {
+      URL.revokeObjectURL(url);
+      video.removeAttribute("src");
+      video.load();
+    };
+    video.addEventListener("loadeddata", () => {
+      video.addEventListener("seeked", () => {
+        try {
+          const w = video.videoWidth;
+          const h = video.videoHeight;
+          const canvas = document.createElement("canvas");
+          canvas.width = w;
+          canvas.height = h;
+          const ctx = canvas.getContext("2d");
+          ctx.drawImage(video, 0, 0);
+          canvas.toBlob(
+            (posterBlob) => {
+              cleanup();
+              if (!posterBlob) {
+                reject(new Error("Failed to create poster blob"));
+                return;
+              }
+              resolve({ posterBlob, width: w, height: h });
+            },
+            "image/webp",
+            quality / 100
+          );
+        } catch (err) {
+          cleanup();
+          reject(err);
+        }
+      }, { once: true });
+      video.currentTime = isFinite(video.duration) ? Math.min(0.1, video.duration / 2) : 0;
+    }, { once: true });
+    video.addEventListener("error", () => {
+      cleanup();
+      reject(new Error("Failed to load video for poster generation"));
+    }, { once: true });
+  });
+}
+
+// src/media/index.ts
+function createMediaAdapter(manifest) {
+  return createGitHubMediaAdapter(manifest);
+}
+
+export {
+  hashFileBuffer,
+  sanitizeMediaName,
+  MIME_TO_EXT,
+  EXT_TO_MIME,
+  mimeToExt,
+  displayFilenameExt,
+  ProcessingQueue,
+  resolveMedia,
+  resolveManifestReferences,
+  generateVideoPoster,
+  createMediaAdapter
+};

package/dist/chunk-T4BJ6RSB.js

@@ -0,0 +1,58 @@
+import {
+  HexColorSchema
+} from "./chunk-UKEVUCIZ.js";
+
+// src/schemas/audience.ts
+import { z } from "zod";
+var AudienceNameSchema = z.string().min(1).max(32).regex(
+  /^[a-z0-9]([a-z0-9_-]*[a-z0-9])?$/,
+  "lowercase alphanumeric, dashes and underscores allowed"
+);
+var AudienceColorSchema = HexColorSchema.nullable();
+function slugifyAudienceName(input) {
+  return input.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+
+// src/schemas/media-grid-options.ts
+import { z as z2 } from "zod";
+var MediaGridOptionsSchema = z2.object({
+  square: z2.boolean().optional(),
+  border: z2.boolean().optional(),
+  crop: z2.boolean().optional(),
+  showCaptions: z2.boolean().optional()
+}).default({});
+
+// src/schemas/auth.ts
+import { z as z3 } from "zod";
+var RoleSchema = z3.enum(["owner", "editor"]);
+var SessionSchema = z3.object({
+  userId: z3.string().nullable(),
+  email: z3.string().nullable(),
+  role: RoleSchema,
+  siteId: z3.string()
+});
+var SiteUserSchema = z3.object({
+  id: z3.string(),
+  email: z3.string(),
+  role: RoleSchema,
+  createdAt: z3.string()
+});
+var AudienceSchema = z3.object({
+  name: z3.string(),
+  displayName: z3.string(),
+  color: z3.string().nullable(),
+  readonly: z3.boolean(),
+  hasPassword: z3.boolean(),
+  isDefault: z3.boolean()
+});
+
+export {
+  AudienceNameSchema,
+  AudienceColorSchema,
+  slugifyAudienceName,
+  MediaGridOptionsSchema,
+  RoleSchema,
+  SessionSchema,
+  SiteUserSchema,
+  AudienceSchema
+};

package/dist/chunk-UKEVUCIZ.js

@@ -0,0 +1,200 @@
+import {
+  MediaConfigSchema
+} from "./chunk-UMSFICAC.js";
+
+// src/schemas/shared.ts
+import { z } from "zod";
+var TextHeadingLine = z.object({
+  type: z.literal("heading"),
+  text: z.string()
+});
+var TextParagraphLine = z.object({
+  type: z.enum(["paragraph", "paragraph_large"]),
+  text: z.string()
+});
+var TextLabelValueLine = z.object({
+  type: z.literal("label_value"),
+  label: z.string(),
+  text: z.string()
+});
+var TextListItemLine = z.object({
+  type: z.enum(["list_item_unordered", "list_item_ordered"]),
+  text: z.string()
+});
+var TextLineSchema = z.discriminatedUnion("type", [
+  TextHeadingLine,
+  TextParagraphLine,
+  TextLabelValueLine,
+  TextListItemLine
+]);
+var BaseMediaRef = z.object({
+  imageId: z.string().default(""),
+  caption: z.union([z.string(), z.array(z.string())]).optional(),
+  background: z.string().optional(),
+  invertFrom: z.string().optional(),
+  border: z.boolean().optional(),
+  objectFit: z.enum(["cover", "contain"]).optional()
+});
+var ImageRef = BaseMediaRef.extend({
+  type: z.literal("image")
+});
+var VideoRef = BaseMediaRef.extend({
+  type: z.literal("video"),
+  poster: z.string().optional(),
+  autoplay: z.boolean().optional(),
+  loop: z.boolean().optional(),
+  muted: z.boolean().optional()
+});
+var DoDontImageRef = BaseMediaRef.extend({
+  type: z.literal("doDontImage"),
+  doDont: z.enum(["do", "dont"])
+});
+var LinkedImageRef = BaseMediaRef.extend({
+  type: z.literal("linkedImage"),
+  href: z.string(),
+  target: z.string().optional(),
+  linkText: z.string().optional()
+});
+var MediaReferenceSchema = z.discriminatedUnion("type", [
+  ImageRef,
+  VideoRef,
+  DoDontImageRef,
+  LinkedImageRef
+]);
+var HexColorSchema = z.string().regex(/^#[0-9a-fA-F]{6}$/, "must be a 6-digit hex color");
+var ColorSpaceSchema = z.object({
+  hex: HexColorSchema.optional(),
+  rgb: z.string().optional(),
+  cmyk: z.string().optional(),
+  pantone: z.string().optional()
+}).refine(
+  (data) => data.hex !== void 0 || data.rgb !== void 0 || data.cmyk !== void 0 || data.pantone !== void 0,
+  { message: "At least one color space must be defined" }
+);
+var ColorItemSchema = z.object({
+  name: z.string().optional(),
+  spaces: z.array(ColorSpaceSchema).min(1)
+});
+
+// src/lib/registry.ts
+function defineSection(def) {
+  return def;
+}
+function createRegistry() {
+  const sections = /* @__PURE__ */ new Map();
+  const schemas = /* @__PURE__ */ new Map();
+  return {
+    registerSection(def) {
+      if (sections.has(def.type)) {
+        throw new Error(`Section type "${def.type}" is already registered`);
+      }
+      sections.set(def.type, def);
+    },
+    registerSchema(type, schema) {
+      schemas.set(type, schema);
+    },
+    getSection(type) {
+      return sections.get(type);
+    },
+    getSchema(type) {
+      return schemas.get(type) ?? sections.get(type)?.schema;
+    },
+    getAllSections() {
+      return Array.from(sections.values());
+    },
+    getAllSchemas() {
+      const merged = new Map(schemas);
+      for (const [type, def] of sections) {
+        if (!merged.has(type)) merged.set(type, def.schema);
+      }
+      return Array.from(merged.values());
+    },
+    clearRegistry() {
+      sections.clear();
+      schemas.clear();
+    }
+  };
+}
+var defaultRegistry = createRegistry();
+function registerSection(def) {
+  defaultRegistry.registerSection(def);
+}
+function registerSchema(type, schema) {
+  defaultRegistry.registerSchema(type, schema);
+}
+function getSection(type) {
+  return defaultRegistry.getSection(type);
+}
+function getSchema(type) {
+  return defaultRegistry.getSchema(type);
+}
+function getAllSections() {
+  return defaultRegistry.getAllSections();
+}
+function getAllSchemas() {
+  return defaultRegistry.getAllSchemas();
+}
+function clearRegistry() {
+  defaultRegistry.clearRegistry();
+}
+
+// src/schemas/sections.ts
+import { z as z2 } from "zod";
+function getSectionContentSchema() {
+  const schemas = getAllSchemas();
+  if (schemas.length < 2) {
+    throw new Error("At least 2 section schemas must be registered before validation");
+  }
+  return z2.union(schemas);
+}
+function getSectionSchema() {
+  return z2.object({ id: z2.string() }).and(getSectionContentSchema());
+}
+
+// src/schemas/site-config.ts
+import { z as z3 } from "zod";
+var SectionMetaSchema = z3.object({
+  type: z3.string(),
+  status: z3.enum(["draft", "published", "archived"]),
+  access: z3.array(z3.string())
+});
+var IndexSchema = z3.object({
+  siteId: z3.string(),
+  order: z3.array(z3.string()),
+  sections: z3.record(z3.string(), SectionMetaSchema)
+}).refine(
+  (data) => data.order.every((id) => id in data.sections),
+  { message: "All order entries must have a corresponding section in sections" }
+);
+var SiteConfigSchema = z3.object({
+  siteName: z3.string().default("Brand Portal"),
+  primaryColor: HexColorSchema.default("#009ca6"),
+  primaryContrast: HexColorSchema.default("#f0f0f0"),
+  darkMode: z3.enum(["light", "dark", "optional"]).default("light"),
+  headingFont: z3.string().default("system-ui"),
+  bodyFont: z3.string().default("system-ui"),
+  googleFontsUrl: z3.string().refine((url) => url.startsWith("https://fonts.googleapis.com/"), "Must be a Google Fonts URL").nullable().default(null),
+  media: MediaConfigSchema.default(MediaConfigSchema.parse({}))
+});
+
+export {
+  TextLineSchema,
+  MediaReferenceSchema,
+  HexColorSchema,
+  ColorSpaceSchema,
+  ColorItemSchema,
+  defineSection,
+  createRegistry,
+  registerSection,
+  registerSchema,
+  getSection,
+  getSchema,
+  getAllSections,
+  getAllSchemas,
+  clearRegistry,
+  getSectionContentSchema,
+  getSectionSchema,
+  SectionMetaSchema,
+  IndexSchema,
+  SiteConfigSchema
+};

package/dist/chunk-UMSFICAC.js

@@ -0,0 +1,36 @@
+// src/schemas/media.ts
+import { z } from "zod";
+var VariantSchema = z.object({
+  width: z.number().int().positive(),
+  height: z.number().int().positive(),
+  size: z.number().int().nonnegative()
+});
+var MediaItemSchema = z.object({
+  id: z.string(),
+  hash: z.string(),
+  kind: z.enum(["image", "animated", "video"]),
+  originalName: z.string(),
+  width: z.number().int().positive(),
+  height: z.number().int().positive(),
+  mimeType: z.string(),
+  size: z.number().int().nonnegative(),
+  folder: z.string(),
+  variants: z.array(VariantSchema),
+  alt: z.string().default("")
+});
+var ImageManifestSchema = z.object({
+  images: z.record(z.string(), MediaItemSchema)
+});
+var MediaConfigSchema = z.object({
+  adapter: z.enum(["github"]).default("github"),
+  sizes: z.array(z.number()).default([640, 1080, 1920]),
+  maxFileSize: z.number().default(5242880),
+  quality: z.number().min(1).max(100).default(85)
+});
+
+export {
+  VariantSchema,
+  MediaItemSchema,
+  ImageManifestSchema,
+  MediaConfigSchema
+};