@astronox/core 0.2.4 → 0.3.1

package/src/components/seo/SeoHead.astro

@@ -72,12 +72,7 @@ const jsonLdNodes = [
 <title>{seo.documentTitle}</title>
 {
   site.seo.icons?.map((icon) => (
-    <link
-      rel="icon"
-      href={icon.href}
-      type={icon.type}
-      sizes={icon.sizes}
-    />
+    <link rel="icon" href={icon.href} type={icon.type} sizes={icon.sizes} />
   ))
 }
 {
@@ -99,10 +94,30 @@ const jsonLdNodes = [
     <meta
       name="theme-color"
       content={themeColor.color}
+      data-theme-color={themeColor.theme}
       media={themeColor.media}
     />
   ))
 }
+<script is:inline>
+  (() => {
+    const applyThemeColor = (theme) => {
+      if (theme !== 'light' && theme !== 'dark') return;
+
+      for (const meta of document.querySelectorAll(
+        'meta[name="theme-color"][data-theme-color]',
+      )) {
+        if (!(meta instanceof HTMLMetaElement)) continue;
+        meta.media = meta.dataset.themeColor === theme ? 'all' : 'not all';
+      }
+    };
+
+    applyThemeColor(document.documentElement.dataset.theme);
+    document.addEventListener('astronox:theme-change', (event) => {
+      applyThemeColor(event.detail?.theme);
+    });
+  })();
+</script>
 <meta name="application-name" content={site.identity.name} />
 <meta name="apple-mobile-web-app-title" content={site.identity.name} />
 {seo.description ? <meta name="description" content={seo.description} /> : null}

package/src/composition/SurfaceGroup/SurfaceGroup.css

@@ -34,9 +34,7 @@
   content: '';
 }
 
-.surface-group:has(> [data-sticky-surface]):not(
-    [data-sticky-measured]
-  )::before,
+.surface-group:has(> [data-sticky-surface]):not([data-sticky-measured])::before,
 .surface-group[data-sticky-active]::before {
   visibility: visible;
 }
@@ -52,16 +50,10 @@
     [data-surface-sizing='content']
   ),
 .surface-group
-  > [data-surface]:not([hidden]):not(
-    [data-surface-sizing='content']
-  ):has(
+  > [data-surface]:not([hidden]):not([data-surface-sizing='content']):has(
     ~ [data-surface]:not([hidden])[data-surface-sizing='content']
   ):not(
-    :has(
-      ~ [data-surface]:not([hidden]):not(
-          [data-surface-sizing='content']
-        )
-    )
+    :has(~ [data-surface]:not([hidden]):not([data-surface-sizing='content']))
   ) {
   flex: 1 1 auto;
   min-height: 0;
@@ -73,9 +65,7 @@
   border-end-end-radius: 0;
 }
 
-.surface-group
-  > [data-surface]:not([hidden])
-  ~ [data-surface]:not([hidden]) {
+.surface-group > [data-surface]:not([hidden]) ~ [data-surface]:not([hidden]) {
   border-block-start-width: 0;
   border-start-start-radius: 0;
   border-start-end-radius: 0;

package/src/config/environment.ts

@@ -0,0 +1,52 @@
+export function readRequiredEnvironmentValue(
+  name: string,
+  value: string | undefined,
+): string {
+  const resolved = value?.trim();
+  if (!resolved) throw new Error(`Missing environment variable: ${name}`);
+  return resolved;
+}
+
+export function readOptionalEnvironmentValue(
+  value: string | undefined,
+): string | undefined {
+  const resolved = value?.trim();
+  return resolved || undefined;
+}
+
+export function readRequiredEnvironmentUrl(
+  name: string,
+  value: string | undefined,
+): string {
+  const resolved = readRequiredEnvironmentValue(name, value);
+
+  try {
+    const url = new URL(resolved);
+    if (url.protocol !== 'http:' && url.protocol !== 'https:')
+      throw new Error();
+    return url.toString();
+  } catch {
+    throw new Error(`Invalid environment URL: ${name}`);
+  }
+}
+
+export function readEnvironmentRecord(
+  name: string,
+  value: string | undefined,
+): Readonly<Record<string, string>> {
+  const resolved = readRequiredEnvironmentValue(name, value);
+
+  try {
+    const parsed: unknown = JSON.parse(resolved);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+      throw new Error();
+    }
+
+    const entries = Object.entries(parsed);
+    if (entries.some(([, entry]) => typeof entry !== 'string'))
+      throw new Error();
+    return Object.fromEntries(entries) as Readonly<Record<string, string>>;
+  } catch {
+    throw new Error(`Invalid environment record: ${name}`);
+  }
+}

package/src/config/index.ts

@@ -1,2 +1,5 @@
+export * from './environment';
+export * from './integrations';
 export * from './pageMeta';
 export * from './siteConfig';
+export * from './storage';

package/src/config/integrations.ts

@@ -0,0 +1,9 @@
+export type IntegrationConfig = Readonly<
+  Record<string, Readonly<Record<string, boolean>>>
+>;
+
+export function defineIntegrationConfig<
+  const TConfig extends IntegrationConfig,
+>(config: TConfig): TConfig {
+  return config;
+}

package/src/config/siteConfig.ts

@@ -1,4 +1,5 @@
 import type { PageMeta } from './pageMeta';
+import type { ColorTheme } from '../theme/contracts';
 
 export type SiteTextDirection = 'ltr' | 'rtl';
 
@@ -13,6 +14,7 @@ export type SiteLocaleConfig = {
 };
 
 export type SiteIdentity = {
+  id: string;
   name: string;
   shortName?: string;
   logo?: {
@@ -34,6 +36,7 @@ export type SiteIconConfig = {
 export type SiteThemeColor = {
   color: string;
   media?: string;
+  theme?: ColorTheme;
 };
 
 export type SiteSeoConfig = {
@@ -68,6 +71,10 @@ export type SiteConfig = {
 export function defineSiteConfig<const TConfig extends SiteConfig>(
   config: TConfig,
 ): TConfig {
+  if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(config.identity.id)) {
+    throw new Error(`Invalid site identity: ${config.identity.id}`);
+  }
+
   const localeIds = new Set<string>();
   const urlCodes = new Set<string>();
 

package/src/config/storage.ts

@@ -0,0 +1,16 @@
+const storageSegmentPattern = /^[a-z0-9][a-z0-9-]*$/;
+
+export function createSiteStorageKey(
+  siteId: string,
+  ...segments: readonly string[]
+): string {
+  const values = [siteId, ...segments];
+  if (
+    segments.length === 0 ||
+    values.some((segment) => !storageSegmentPattern.test(segment))
+  ) {
+    throw new Error('Invalid site storage key');
+  }
+
+  return values.join(':');
+}

package/src/content/admin.ts

@@ -0,0 +1,354 @@
+import type { AdminResource } from '../admin';
+import type { AuthActor } from '../auth';
+import type {
+  ContentDocument,
+  ContentDocumentAdminRepository,
+  ContentDocumentDraft,
+  ContentOrder,
+  ContentPlacement,
+  ContentPlacementAdminRepository,
+  ContentPlacementDraft,
+} from './contracts';
+
+type IndexInput = { cursor?: string; limit?: number } | undefined;
+
+export type ContentAdminSnapshotReader<
+  TPlacement extends ContentPlacement,
+  TDocument extends ContentDocument,
+> = {
+  getDocuments(actor: AuthActor): readonly TDocument[] | null;
+  getPlacements(actor: AuthActor): readonly TPlacement[] | null;
+};
+
+export type ContentAdminErrors = {
+  documentNotFound: string;
+  documentSlugExists: string;
+  placementInUse: string;
+  placementKeyExists: string;
+  placementNotFound: string;
+};
+
+export function createContentAdminResources<
+  TPlacement extends ContentPlacement,
+  TDocument extends ContentDocument,
+  TPlacementDraft extends ContentPlacementDraft,
+  TDocumentDraft extends ContentDocumentDraft,
+>({
+  assertRootSlug,
+  documents,
+  errors,
+  parseDocumentDraft,
+  parsePlacementDraft,
+  placements,
+  requireWriteAccess,
+  rootPlacementKey,
+  snapshots,
+}: {
+  assertRootSlug?(slug: string): void;
+  documents: ContentDocumentAdminRepository<TDocument, TDocumentDraft>;
+  errors: ContentAdminErrors;
+  parseDocumentDraft(input: unknown): TDocumentDraft;
+  parsePlacementDraft(input: unknown): TPlacementDraft;
+  placements: ContentPlacementAdminRepository<TPlacement, TPlacementDraft>;
+  requireWriteAccess(actor: AuthActor): void;
+  rootPlacementKey?: string;
+  snapshots: ContentAdminSnapshotReader<TPlacement, TDocument>;
+}) {
+  const placementResource: AdminResource<
+    TPlacement,
+    TPlacementDraft,
+    TPlacementDraft,
+    IndexInput
+  > = {
+    getIndex: (input) => placements.getIndex(input),
+    getDetail: (input) => placements.getDetail(input),
+    async create(input, actor) {
+      requireWriteAccess(actor);
+      const draft = parsePlacementDraft(input);
+      const allPlacements = await loadAll(
+        placements,
+        snapshots.getPlacements(actor),
+      );
+      assertUniquePlacementKey(allPlacements, draft.key, errors);
+      return placements.create(draft);
+    },
+    async update({ id, value }, actor) {
+      requireWriteAccess(actor);
+      const draft = parsePlacementDraft(value);
+      const allPlacements = await loadAll(
+        placements,
+        snapshots.getPlacements(actor),
+      );
+      const current = allPlacements.find((placement) => placement.id === id);
+      if (!current) throw new Error(errors.placementNotFound);
+      if (samePlacement(current, draft)) return current;
+      assertUniquePlacementKey(allPlacements, draft.key, errors, id);
+      if (
+        rootPlacementKey &&
+        draft.key === rootPlacementKey &&
+        assertRootSlug
+      ) {
+        const allDocuments = await loadAll(
+          documents,
+          snapshots.getDocuments(actor),
+        );
+        allDocuments
+          .filter((document) => document.placementId === id)
+          .forEach((document) => assertRootSlug(document.slug));
+      }
+      return placements.update({ id, value: draft });
+    },
+    async delete({ id }, actor) {
+      requireWriteAccess(actor);
+      const allDocuments = await loadAll(
+        documents,
+        snapshots.getDocuments(actor),
+      );
+      if (allDocuments.some((document) => document.placementId === id)) {
+        throw new Error(errors.placementInUse);
+      }
+      return placements.delete({ id });
+    },
+  };
+
+  const documentResource: AdminResource<
+    TDocument,
+    TDocumentDraft,
+    TDocumentDraft,
+    IndexInput
+  > = {
+    getIndex: (input) => documents.getIndex(input),
+    getDetail: (input) => documents.getDetail(input),
+    async create(input, actor) {
+      requireWriteAccess(actor);
+      const draft = parseDocumentDraft(input);
+      const [allDocuments, placement] = await Promise.all([
+        loadAll(documents, snapshots.getDocuments(actor)),
+        findPlacement(
+          placements,
+          draft.placementId,
+          snapshots.getPlacements(actor),
+        ),
+      ]);
+      assertDocumentReferences(
+        placement,
+        allDocuments,
+        draft,
+        errors,
+        rootPlacementKey,
+        assertRootSlug,
+      );
+      const siblings = allDocuments.filter(
+        (document) => document.placementId === draft.placementId,
+      );
+      const position = Math.min(draft.order, siblings.length + 1);
+      return documents.createOrdered({
+        value: { ...draft, order: position },
+        orders: changedOrders(allDocuments, insertOrders(siblings, position)),
+      });
+    },
+    async update({ id, value }, actor) {
+      requireWriteAccess(actor);
+      const draft = parseDocumentDraft(value);
+      const allDocuments = await loadAll(
+        documents,
+        snapshots.getDocuments(actor),
+      );
+      const current = allDocuments.find((document) => document.id === id);
+      if (!current) throw new Error(errors.documentNotFound);
+      const placement = await findPlacement(
+        placements,
+        draft.placementId,
+        snapshots.getPlacements(actor),
+      );
+      assertDocumentReferences(
+        placement,
+        allDocuments,
+        draft,
+        errors,
+        rootPlacementKey,
+        assertRootSlug,
+        id,
+      );
+      const previousSiblings = allDocuments.filter(
+        (document) =>
+          document.id !== id && document.placementId === current.placementId,
+      );
+      const nextSiblings = allDocuments.filter(
+        (document) =>
+          document.id !== id && document.placementId === draft.placementId,
+      );
+      const position = Math.min(draft.order, nextSiblings.length + 1);
+      const valueWithOrder = { ...draft, order: position };
+      const orders =
+        current.placementId === draft.placementId
+          ? insertOrders(nextSiblings, position)
+          : [
+              ...normalizeOrders(previousSiblings),
+              ...insertOrders(nextSiblings, position),
+            ];
+      const updates = changedOrders(allDocuments, orders).filter(
+        (order) => order.id !== id,
+      );
+      if (sameDocument(current, valueWithOrder) && updates.length === 0) {
+        return current;
+      }
+      return documents.updateOrdered({
+        id,
+        value: valueWithOrder,
+        orders: updates,
+      });
+    },
+    async delete({ id }, actor) {
+      requireWriteAccess(actor);
+      const allDocuments = await loadAll(
+        documents,
+        snapshots.getDocuments(actor),
+      );
+      const current = allDocuments.find((document) => document.id === id);
+      if (!current) return;
+      const siblings = allDocuments.filter(
+        (document) =>
+          document.id !== id && document.placementId === current.placementId,
+      );
+      await documents.deleteOrdered({
+        id,
+        orders: changedOrders(allDocuments, normalizeOrders(siblings)),
+      });
+    },
+  };
+
+  return {
+    documents: documentResource,
+    placements: placementResource,
+  } as const;
+}
+
+export async function loadAdminIndex<T>(
+  repository: {
+    getIndex(input?: IndexInput): Promise<{
+      items: readonly T[];
+      nextCursor?: string;
+    }>;
+  },
+  cached?: readonly T[] | null,
+): Promise<T[]> {
+  return loadAll(repository, cached);
+}
+
+function assertUniquePlacementKey(
+  placements: readonly ContentPlacement[],
+  key: string,
+  errors: ContentAdminErrors,
+  exceptId?: string,
+): void {
+  if (placements.some((item) => item.id !== exceptId && item.key === key)) {
+    throw new Error(errors.placementKeyExists);
+  }
+}
+
+function assertDocumentReferences<
+  TPlacement extends ContentPlacement,
+  TDocument extends ContentDocument,
+>(
+  placement: TPlacement | null,
+  documents: readonly TDocument[],
+  draft: ContentDocumentDraft,
+  errors: ContentAdminErrors,
+  rootPlacementKey?: string,
+  assertRootSlug?: (slug: string) => void,
+  exceptId?: string,
+): void {
+  if (!placement) throw new Error(errors.placementNotFound);
+  if (rootPlacementKey && placement.key === rootPlacementKey) {
+    assertRootSlug?.(draft.slug);
+  }
+  if (
+    documents.some(
+      (document) => document.id !== exceptId && document.slug === draft.slug,
+    )
+  ) {
+    throw new Error(errors.documentSlugExists);
+  }
+}
+
+function findPlacement<TPlacement extends ContentPlacement>(
+  repository: { getDetail(input: { id: string }): Promise<TPlacement | null> },
+  id: string,
+  cached: readonly TPlacement[] | null,
+): Promise<TPlacement | null> {
+  const placement = cached?.find((candidate) => candidate.id === id);
+  return placement ? Promise.resolve(placement) : repository.getDetail({ id });
+}
+
+function insertOrders(
+  siblings: readonly ContentDocument[],
+  position: number,
+): ContentOrder[] {
+  return [...siblings]
+    .sort((left, right) => left.order - right.order)
+    .map((document, index) => ({
+      id: document.id,
+      order: index + 1 >= position ? index + 2 : index + 1,
+    }));
+}
+
+function normalizeOrders(
+  documents: readonly ContentDocument[],
+): ContentOrder[] {
+  return [...documents]
+    .sort((left, right) => left.order - right.order)
+    .map((document, index) => ({ id: document.id, order: index + 1 }));
+}
+
+function changedOrders(
+  documents: readonly ContentDocument[],
+  orders: readonly ContentOrder[],
+): ContentOrder[] {
+  const current = new Map(
+    documents.map((document) => [document.id, document.order]),
+  );
+  return orders.filter((order) => current.get(order.id) !== order.order);
+}
+
+function samePlacement(
+  placement: ContentPlacement,
+  draft: ContentPlacementDraft,
+): boolean {
+  return placement.key === draft.key && placement.title === draft.title;
+}
+
+function sameDocument(
+  document: ContentDocument,
+  draft: ContentDocumentDraft,
+): boolean {
+  return (
+    document.content === draft.content &&
+    document.order === draft.order &&
+    document.placementId === draft.placementId &&
+    document.slug === draft.slug &&
+    document.summary === draft.summary &&
+    document.title === draft.title &&
+    document.visibility === draft.visibility
+  );
+}
+
+async function loadAll<T>(
+  repository: {
+    getIndex(input?: IndexInput): Promise<{
+      items: readonly T[];
+      nextCursor?: string;
+    }>;
+  },
+  cached?: readonly T[] | null,
+): Promise<T[]> {
+  if (cached) return [...cached];
+  const items: T[] = [];
+  let cursor: string | undefined;
+  do {
+    const page = await repository.getIndex({ cursor, limit: 100 });
+    items.push(...page.items);
+    cursor = page.nextCursor;
+  } while (cursor);
+  return items;
+}