@astronox/core 0.2.4 → 0.3.0

package/src/content/drafts.ts

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+import type { ContentDocumentDraft, ContentPlacementDraft } from './contracts';
+
+export const contentKeySchema = z
+  .string()
+  .trim()
+  .min(1)
+  .max(80)
+  .transform((value) =>
+    value
+      .normalize('NFKD')
+      .replace(/[\u0300-\u036f]/g, '')
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, '-')
+      .replace(/^-+|-+$/g, ''),
+  )
+  .pipe(z.string().min(1));
+
+const placementDraftSchema = z.object({
+  key: contentKeySchema,
+  title: z.string().trim().min(1).max(120),
+});
+
+const documentDraftSchema = z.object({
+  placementId: z.string().trim().min(1),
+  content: z.string().trim().min(1).max(200_000),
+  order: z.coerce.number().int().positive(),
+  slug: contentKeySchema,
+  summary: z
+    .string()
+    .trim()
+    .max(500)
+    .optional()
+    .transform((value) => value || undefined),
+  title: z.string().trim().min(1).max(160),
+  visibility: z.enum(['public', 'private']),
+});
+
+export function parseContentPlacementDraft(
+  input: unknown,
+): ContentPlacementDraft {
+  return placementDraftSchema.parse(input);
+}
+
+export function parseContentDocumentDraft(
+  input: unknown,
+): ContentDocumentDraft {
+  return documentDraftSchema.parse(input);
+}

package/src/content/index.ts

@@ -0,0 +1,7 @@
+export * from './admin';
+export * from './cache';
+export * from './catalog';
+export * from './contracts';
+export * from './drafts';
+export * from './markdown';
+export * from './snapshot';

package/src/content/markdown.ts

@@ -0,0 +1,146 @@
+import { fromMarkdown } from 'mdast-util-from-markdown';
+import type {
+  MarkdownBlock,
+  MarkdownDocument,
+  MarkdownHeadingLevel,
+  MarkdownInline,
+} from '../components/content/MarkdownContent/contracts';
+
+type AstNode = {
+  children?: AstNode[];
+  depth?: number;
+  lang?: string;
+  type?: string;
+  url?: string;
+  value?: string;
+};
+
+export function parseMarkdownDocument(source: string): MarkdownDocument {
+  const root = fromMarkdown(source) as AstNode;
+  const headingIds = new Map<string, number>();
+  return {
+    blocks: (root.children ?? []).flatMap((node) => toBlocks(node, headingIds)),
+  };
+}
+
+function toBlocks(
+  node: AstNode,
+  headingIds: Map<string, number>,
+): MarkdownBlock[] {
+  switch (node.type) {
+    case 'paragraph':
+      return [{ type: 'paragraph', children: toInlineChildren(node) }];
+    case 'heading': {
+      const children = toInlineChildren(node);
+      const title = inlineText(children);
+      const level = Math.min(
+        6,
+        Math.max(2, node.depth ?? 2),
+      ) as MarkdownHeadingLevel;
+      return [
+        {
+          type: 'heading',
+          children,
+          id: uniqueSlug(title, headingIds),
+          level,
+        },
+      ];
+    }
+    case 'list':
+      return [
+        {
+          type: 'list',
+          items: (node.children ?? [])
+            .filter((item) => item.type === 'listItem')
+            .map((item) => ({
+              children: (item.children ?? []).flatMap((child) =>
+                toBlocks(child, headingIds),
+              ),
+            })),
+        },
+      ];
+    case 'blockquote':
+      return [
+        {
+          type: 'quote',
+          children: (node.children ?? []).flatMap((child) =>
+            toBlocks(child, headingIds),
+          ),
+        },
+      ];
+    case 'code':
+      return [
+        {
+          type: 'code',
+          language: node.lang,
+          value: node.value ?? '',
+        },
+      ];
+    case 'thematicBreak':
+      return [{ type: 'separator' }];
+    default:
+      return [];
+  }
+}
+
+function toInlineChildren(node: AstNode): MarkdownInline[] {
+  return (node.children ?? []).flatMap(toInline);
+}
+
+function toInline(node: AstNode): MarkdownInline[] {
+  switch (node.type) {
+    case 'text':
+      return [{ type: 'text', value: node.value ?? '' }];
+    case 'strong':
+      return [{ type: 'strong', children: toInlineChildren(node) }];
+    case 'emphasis':
+      return [{ type: 'emphasis', children: toInlineChildren(node) }];
+    case 'inlineCode':
+      return [{ type: 'code', value: node.value ?? '' }];
+    case 'break':
+      return [{ type: 'break' }];
+    case 'link': {
+      const href = node.url ?? '';
+      return [
+        {
+          type: 'link',
+          children: toInlineChildren(node),
+          external: /^(?:https?:)?\/\//i.test(href),
+          href,
+        },
+      ];
+    }
+    default:
+      return [];
+  }
+}
+
+function inlineText(nodes: readonly MarkdownInline[]): string {
+  return nodes
+    .map((node) => {
+      if (node.type === 'text' || node.type === 'code') return node.value;
+      if (
+        node.type === 'strong' ||
+        node.type === 'emphasis' ||
+        node.type === 'link'
+      ) {
+        return inlineText(node.children);
+      }
+      return '';
+    })
+    .join('')
+    .trim();
+}
+
+function uniqueSlug(value: string, counts: Map<string, number>): string {
+  const base =
+    value
+      .normalize('NFKD')
+      .replace(/[\u0300-\u036f]/g, '')
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, '-')
+      .replace(/^-+|-+$/g, '') || 'section';
+  const count = counts.get(base) ?? 0;
+  counts.set(base, count + 1);
+  return count === 0 ? base : `${base}-${count + 1}`;
+}

package/src/content/snapshot.ts

@@ -0,0 +1,139 @@
+import type {
+  ContentDocument,
+  ContentPlacement,
+  ContentSnapshot,
+} from './contracts';
+
+type RecordValue = Record<string, unknown>;
+
+export type ContentSnapshotFields = {
+  documents: string;
+  documentPlacementId: string;
+  label: string;
+  placements: string;
+};
+
+export function parseContentSnapshot(
+  value: unknown,
+  fields: ContentSnapshotFields,
+): ContentSnapshot {
+  const source = requireRecord(value, fields.label);
+  const rawPlacements = requireArray(source[fields.placements], fields.label);
+  const rawDocuments = requireArray(source[fields.documents], fields.label);
+  const placements = rawPlacements.map((entry) =>
+    parsePlacement(entry, fields.label),
+  );
+  const documents = rawDocuments.map((entry) =>
+    parseDocument(entry, fields.documentPlacementId, fields.label),
+  );
+  const placementIds = new Set(placements.map((placement) => placement.id));
+
+  for (const document of documents) {
+    if (!placementIds.has(document.placementId)) {
+      throw new Error(
+        `Invalid ${fields.label} document placement: ${document.id}`,
+      );
+    }
+  }
+
+  return {
+    placements,
+    documents,
+    updatedAt:
+      source.updatedAt === undefined || source.updatedAt === null
+        ? null
+        : parseSnapshotDate(source.updatedAt, fields.label),
+  };
+}
+
+export function projectPublicContentSnapshot<
+  TPlacement extends ContentPlacement,
+  TDocument extends ContentDocument,
+>(
+  snapshot: ContentSnapshot<TPlacement, TDocument>,
+): ContentSnapshot<TPlacement, TDocument> {
+  return {
+    ...snapshot,
+    documents: snapshot.documents.filter(
+      (document) => document.visibility === 'public',
+    ),
+  };
+}
+
+export function parseSnapshotDate(value: unknown, label = 'snapshot'): Date {
+  const timestamp = isRecord(value)
+    ? typeof value._seconds === 'number'
+      ? value._seconds * 1_000
+      : typeof value.seconds === 'number'
+        ? value.seconds * 1_000
+        : Number.NaN
+    : value;
+  const date = new Date(timestamp as string | number | Date);
+  if (Number.isNaN(date.getTime())) throw new Error(`Invalid ${label} date`);
+  return date;
+}
+
+function parsePlacement(value: unknown, label: string): ContentPlacement {
+  const source = requireRecord(value, label);
+  return {
+    id: requireString(source.id, label),
+    key: requireString(source.key, label),
+    title: requireString(source.title, label),
+  };
+}
+
+function parseDocument(
+  value: unknown,
+  placementIdField: string,
+  label: string,
+): ContentDocument {
+  const source = requireRecord(value, label);
+  const order =
+    typeof source.order === 'number' ? source.order : Number(source.order);
+  if (!Number.isInteger(order) || order < 1) {
+    throw new Error(`Invalid ${label} document order`);
+  }
+  if (source.private !== undefined && typeof source.private !== 'boolean') {
+    throw new Error(`Invalid ${label} document visibility`);
+  }
+  const summary = readOptionalString(source.summary, label);
+
+  return {
+    content: requireString(source.content, label),
+    id: requireString(source.id, label),
+    order,
+    placementId: requireString(source[placementIdField], label),
+    slug: requireString(source.slug, label),
+    ...(summary ? { summary } : {}),
+    title: requireString(source.title, label),
+    updatedAt: parseSnapshotDate(source.updatedAt, label),
+    visibility: source.private === true ? 'private' : 'public',
+  };
+}
+
+function requireArray(value: unknown, label: string): unknown[] {
+  if (!Array.isArray(value)) throw new Error(`Invalid ${label} snapshot`);
+  return value;
+}
+
+function requireRecord(value: unknown, label: string): RecordValue {
+  if (!isRecord(value)) throw new Error(`Invalid ${label} snapshot`);
+  return value;
+}
+
+function requireString(value: unknown, label: string): string {
+  const resolved = typeof value === 'string' ? value.trim() : '';
+  if (!resolved) throw new Error(`Invalid ${label} snapshot string`);
+  return resolved;
+}
+
+function readOptionalString(value: unknown, label: string): string | undefined {
+  if (value === undefined || value === null || value === '') return undefined;
+  if (typeof value !== 'string')
+    throw new Error(`Invalid ${label} optional string`);
+  return value.trim() || undefined;
+}
+
+function isRecord(value: unknown): value is RecordValue {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/src/data/firestore/client/contracts.ts

@@ -1,5 +1,7 @@
 import type { Firestore } from 'firebase/firestore';
 
+export type ClientFirestore = Firestore;
+
 export type ClientFirestorePage<TItem> = {
   items: readonly TItem[];
   nextCursor?: string;
@@ -16,11 +18,12 @@ export type ClientFirestoreCursor<TDocument> = {
 };
 
 export type ClientFirestoreDocumentMapper<
+  TDocument,
   TItem,
   TCreateInput,
   TUpdateInput,
 > = {
-  fromDocument(id: string, value: unknown): TItem;
+  fromDocument(id: string, value: TDocument): TItem;
   toCreate(input: TCreateInput): Record<string, unknown>;
   toUpdate(input: TUpdateInput): Record<string, unknown>;
 };
@@ -49,7 +52,12 @@ export type ClientFirestoreRepositoryConfig<
   collection: string;
   cursor?: ClientFirestoreCursor<TDocument>;
   database: Firestore;
-  mapper: ClientFirestoreDocumentMapper<TItem, TCreateInput, TUpdateInput>;
+  mapper: ClientFirestoreDocumentMapper<
+    TDocument,
+    TItem,
+    TCreateInput,
+    TUpdateInput
+  >;
   orderBy?: readonly ClientFirestoreOrder[];
   schema: ClientFirestoreSchema<TDocument>;
 };

package/src/data/index.ts

@@ -1 +1,2 @@
 export * from './collectionValidation';
+export * from './memoizedLoader';

package/src/data/memoizedLoader.ts

@@ -0,0 +1,13 @@
+export function createMemoizedLoader<T>(
+  load: () => Promise<T>,
+): () => Promise<T> {
+  let pending: Promise<T> | null = null;
+
+  return () => {
+    pending ??= load().catch((reason) => {
+      pending = null;
+      throw reason;
+    });
+    return pending;
+  };
+}

package/src/display/contracts.ts

@@ -175,11 +175,7 @@ export type StageFlowStep = {
 };
 
 export type TableColumnRole =
-  | 'ordinal'
-  | 'media'
-  | 'primary'
-  | 'value'
-  | 'collection';
+  'ordinal' | 'media' | 'primary' | 'value' | 'collection';
 export type TableColumnAlignment = 'start' | 'center' | 'end';
 
 export type TableColumn = {

package/src/i18n/config.ts

@@ -26,10 +26,7 @@ export type LocaleConfig<
 };
 
 export function createLocaleConfig<
-  const TDefinitions extends readonly [
-    LocaleDefinition,
-    ...LocaleDefinition[],
-  ],
+  const TDefinitions extends readonly [LocaleDefinition, ...LocaleDefinition[]],
   const TDefaultLocale extends TDefinitions[number]['id'],
 >({
   defaultLocale,
@@ -100,10 +97,7 @@ export function createLocaleConfig<
     },
     requireLocalizedLocale(value: string): Locale {
       const locale = localeByUrlCode.get(value.toLowerCase())?.id;
-      if (
-        !locale ||
-        (!prefixDefaultLocale && locale === defaultLocale)
-      ) {
+      if (!locale || (!prefixDefaultLocale && locale === defaultLocale)) {
         throw new Error(`Unsupported localized route locale: ${value}`);
       }
       return locale;

package/src/i18n/coreMessages.ts

@@ -1,7 +1,4 @@
-import {
-  resolveLocalizedCatalog,
-  type MessageShape,
-} from './catalog';
+import { resolveLocalizedCatalog, type MessageShape } from './catalog';
 
 export const defaultCoreMessages = {
   actions: {
@@ -29,9 +26,5 @@ export function resolveCoreMessages(
   translated: unknown = undefined,
   locale = 'en',
 ): CoreMessages {
-  return resolveLocalizedCatalog(
-    defaultCoreMessages,
-    translated,
-    locale,
-  );
+  return resolveLocalizedCatalog(defaultCoreMessages, translated, locale);
 }

package/src/i18n/preference.ts

@@ -11,9 +11,7 @@ export function createLocalePreferenceController<TLocale extends string>({
   resolvePath,
   storageKey,
 }: LocalePreferenceControllerOptions<TLocale>) {
-  return function initLocalePreference(
-    root: Document = document,
-  ): () => void {
+  return function initLocalePreference(root: Document = document): () => void {
     const element = root.documentElement;
     if (element.hasAttribute(initializedAttribute)) return () => undefined;
     element.setAttribute(initializedAttribute, '');
@@ -24,9 +22,7 @@ export function createLocalePreferenceController<TLocale extends string>({
 
       const link = target.closest<HTMLAnchorElement>('a[hreflang]');
       const languageTag = link?.getAttribute('hreflang');
-      const locale = languageTag
-        ? resolveLocale(languageTag)
-        : undefined;
+      const locale = languageTag ? resolveLocale(languageTag) : undefined;
       if (!locale) return;
 
       event.preventDefault();

package/src/patterns/Combobox/Combobox.astro

@@ -244,18 +244,15 @@ const searchId = `${props.id}-search`;
   data-tone={resolvedTone}
   data-preference-id={props.preference?.id}
   data-preference-path={props.preference?.path}
-  data-preference-control={
-    props.preference
-      ? mode === 'number'
-        ? 'combobox-number'
-        : 'combobox-options'
-      : undefined
-  }
-  data-preference-number-bounds={
-    mode === 'number' && (props as NumberProps).preferenceBounds
-      ? JSON.stringify((props as NumberProps).preferenceBounds)
-      : undefined
-  }
+  data-preference-control={props.preference
+    ? mode === 'number'
+      ? 'combobox-number'
+      : 'combobox-options'
+    : undefined}
+  data-preference-number-bounds={mode === 'number' &&
+  (props as NumberProps).preferenceBounds
+    ? JSON.stringify((props as NumberProps).preferenceBounds)
+    : undefined}
 >
   <span class="combobox__sizer" aria-hidden="true">
     {

package/src/patterns/Combobox/comboboxController.ts

@@ -105,10 +105,7 @@ function normalizeNumber(value: number, bounds: NumberBounds): number {
   return Math.min(bounds.max, Math.max(bounds.min, stepped));
 }
 
-function syncNumberOptionBounds(
-  root: HTMLElement,
-  bounds: NumberBounds,
-): void {
+function syncNumberOptionBounds(root: HTMLElement, bounds: NumberBounds): void {
   for (const option of getOptions(root)) {
     const value = Number(option.dataset.comboboxOption);
     option.hidden =
@@ -172,12 +169,18 @@ export function setComboboxOptions(
   selectedValues: readonly string[] = [],
 ): void {
   if (root.dataset.comboboxMode === 'number') return;
-  const optionsRoot = root.querySelector<HTMLElement>('[data-combobox-options]');
+  const optionsRoot = root.querySelector<HTMLElement>(
+    '[data-combobox-options]',
+  );
   const empty = root.querySelector<HTMLElement>('[data-combobox-empty]');
   if (!optionsRoot || !empty) return;
 
-  optionsRoot.querySelectorAll('[data-combobox-option]').forEach((node) => node.remove());
-  root.querySelectorAll('template[data-combobox-tag-template]').forEach((node) => node.remove());
+  optionsRoot
+    .querySelectorAll('[data-combobox-option]')
+    .forEach((node) => node.remove());
+  root
+    .querySelectorAll('template[data-combobox-tag-template]')
+    .forEach((node) => node.remove());
 
   options.forEach((option, index) => {
     const button = document.createElement('button');
@@ -190,7 +193,10 @@ export function setComboboxOptions(
     button.setAttribute('aria-selected', 'false');
     if (option.disabled) button.setAttribute('aria-disabled', 'true');
     button.dataset.comboboxOption = option.value;
-    button.dataset.comboboxSearchText = [option.label, option.description ?? ''].join(' ');
+    button.dataset.comboboxSearchText = [
+      option.label,
+      option.description ?? '',
+    ].join(' ');
     button.dataset.interactionAccent = 'start';
 
     const content = document.createElement('span');

package/src/patterns/Fullscreen/FullscreenControl.astro

@@ -12,7 +12,11 @@ type FullscreenUnsupportedFallback = {
   target?: '_blank' | '_self';
 };
 
-type Props = Omit<HTMLAttributes<'button'>, 'aria-controls' | 'type'> & {
+type Props = Omit<
+  HTMLAttributes<'button'>,
+  'aria-controls' | 'disabled' | 'type'
+> & {
+  disabled?: boolean;
   enterLabel: string;
   exitLabel: string;
   targetId: string;

package/src/patterns/Fullscreen/fullscreenController.ts

@@ -1,9 +1,7 @@
 const initializedAttribute = 'data-fullscreen-initialized';
 const noop = (): void => undefined;
 
-export function initFullscreenControl(
-  control: HTMLButtonElement,
-): () => void {
+export function initFullscreenControl(control: HTMLButtonElement): () => void {
   if (control.getAttribute(initializedAttribute) === 'true') return noop;
 
   const targetId = control.dataset.fullscreenTarget;

package/src/patterns/MapViewport/geometry.ts

@@ -1,7 +1,4 @@
-import type {
-  MapViewportModel,
-  MapViewportSizing,
-} from './contracts';
+import type { MapViewportModel, MapViewportSizing } from './contracts';
 
 export type MapViewportSceneGeometry = {
   aspectRatio: string;

package/src/patterns/Modal/Modal.css

@@ -108,10 +108,7 @@ html:has(.modal[open]) [data-site-viewport] {
     padding-inline: 0;
   }
 
-  .modal:not(
-      [data-sizing='adaptive'],
-      [data-sizing='confirmation']
-    )
+  .modal:not([data-sizing='adaptive'], [data-sizing='confirmation'])
     .modal__content
     [data-surface] {
     border-radius: 0;

package/src/patterns/Modal/ModalOpen.astro

@@ -3,7 +3,11 @@ import type { HTMLAttributes } from 'astro/types';
 import type { Tone } from '../../theme/contracts';
 import Button from '../../components/actions/Button/Button.astro';
 
-type Props = Omit<HTMLAttributes<'button'>, 'aria-controls' | 'type'> & {
+type Props = Omit<
+  HTMLAttributes<'button'>,
+  'aria-controls' | 'disabled' | 'type'
+> & {
+  disabled?: boolean;
   label: string;
   targetId: string;
   tone?: Tone;

package/src/patterns/Table/Table.astro

@@ -114,7 +114,7 @@ const resolvedRows = rows.map((row, index): TableRow => ({
   ...row,
   key: row.key ?? `${paginationKey ?? 'table'}-${index + 1}`,
 }));
-const inferredProgressive =
+const inferredProgressive: TableProgressiveModel | undefined =
   progressive === undefined && resolvedRows.length > batchSize
     ? {
         batchSize,
@@ -128,7 +128,7 @@ const inferredProgressive =
 const progressiveModel =
   progressive === false
     ? undefined
-    : configuredProgressive ?? inferredProgressive;
+    : (configuredProgressive ?? inferredProgressive);
 const hasProgressiveRows = Boolean(
   progressiveModel && progressiveModel.entries.length > batchSize,
 );
@@ -171,7 +171,9 @@ if (clientProgressive && !paginationMessages) {
   throw new Error('Client-progressive tables require localized messages');
 }
 if (progressiveModel?.sources && !paginationKey) {
-  throw new Error('External progressive tables require a stable pagination key');
+  throw new Error(
+    'External progressive tables require a stable pagination key',
+  );
 }
 if (rowKeys.size !== resolvedRows.length) {
   throw new Error('Table rows require unique keys');
@@ -193,9 +195,9 @@ if (
   data-table-client-progressive={clientProgressive ? true : undefined}
   data-table-density={density}
   data-table-inline-overflow={inlineOverflow}
-  data-table-index-minimum-rem={
-    minimumInlineSize ? Number.parseFloat(minimumInlineSize) : undefined
-  }
+  data-table-index-minimum-rem={minimumInlineSize
+    ? Number.parseFloat(minimumInlineSize)
+    : undefined}
   data-table-layout={layout}
   data-table-loading-state={initialLoadingState}
   data-table-preparation={preparation}
@@ -209,10 +211,8 @@ if (
     preparesRows ? (
       <script is:inline>
         document.documentElement.setAttribute('data-nox-table-enhanced', '');
-        document.currentScript?.parentElement?.setAttribute(
-          'aria-busy',
-          'true',
-        );
+        document.currentScript?.parentElement?.setAttribute( 'aria-busy',
+        'true', );
       </script>
     ) : null
   }

package/src/patterns/Table/TableBody.astro

@@ -6,10 +6,7 @@ import TableSortIcon from '../../components/icons/TableSortIcon.astro';
 import TextBlock from '../../primitives/text/TextBlock/TextBlock.astro';
 import TableCellContent from './TableCell.astro';
 import TableSkeleton from './TableSkeleton.astro';
-import {
-  getTableColumnAlignment,
-  type TableLayout,
-} from './tableLayout';
+import { getTableColumnAlignment, type TableLayout } from './tableLayout';
 
 type Props = HTMLAttributes<'div'> & {
   caption: string;