@erclx/canon 5.51.0 → 5.53.0

package/src/demo/theme.ts

@@ -1,112 +0,0 @@
-import { readdirSync, readFileSync } from 'node:fs'
-import { join } from 'node:path'
-import { cursorHotspot, type Cursor, type CursorSet } from '@/demo/pointer'
-
-/**
- * Reads a cursor theme folder so `--cursor` can point at one. Spike 3 measured
- * the browser decoding a Windows cursor resource directly, so nothing here
- * converts anything: the bytes go into a data URI and the header supplies the
- * hotspot.
- *
- * Three of the nineteen states a theme carries are read. A drag, a resize, or a
- * wait shows the default arrow where a real session would show something else,
- * and the two animated states have no still frame to draw at all.
- */
-
-const CURSOR_MIME = 'image/x-icon'
-const EXTENSION = /\.cur$/i
-
-/** Ordered per state, most specific first, so an exact name beats a longer one. */
-const NAMES: Record<string, readonly string[]> = {
-  default: ['arrow', 'normal', 'default'],
-  pointer: ['link', 'hand', 'pointer'],
-  text: ['ibeam', 'beam', 'text'],
-}
-
-export type CursorFiles = Partial<Record<string, string>>
-
-/**
- * Picks one file per state out of a directory listing. Matching runs on the
- * name rather than on the contents because a theme states its intent there, and
- * a shorter match wins so `Arrow.cur` beats `Arrow Alternate.cur`.
- */
-export function matchCursorFiles(files: readonly string[]): CursorFiles {
-  const cursors = files.filter((file) => EXTENSION.test(file))
-  const matched: CursorFiles = {}
-
-  for (const [state, names] of Object.entries(NAMES)) {
-    const found = names
-      .flatMap((name) =>
-        cursors.filter((file) => file.toLowerCase().includes(name)),
-      )
-      .sort((left, right) => left.length - right.length)[0]
-    if (found) matched[state] = found
-  }
-
-  return matched
-}
-
-export type ThemeLoad =
-  | { status: 'loaded'; cursors: CursorSet; states: string[] }
-  | { status: 'failed'; reason: string }
-
-/**
- * Falls back to the bundled artwork per state rather than per theme, so a
- * folder carrying an arrow and no hand still contributes its arrow.
- */
-export function loadCursorTheme(dir: string, fallback: CursorSet): ThemeLoad {
-  let listing: string[]
-  try {
-    listing = readdirNames(dir)
-  } catch (error) {
-    return {
-      status: 'failed',
-      reason: `${dir} could not be read: ${message(error)}`,
-    }
-  }
-
-  const matched = matchCursorFiles(listing)
-  const states = Object.keys(matched)
-  if (!states.length) {
-    return {
-      status: 'failed',
-      reason: `${dir} holds no .cur file named after a pointer, link, or text state`,
-    }
-  }
-
-  const cursors: Record<string, Cursor> = { ...fallback }
-  for (const [state, file] of Object.entries(matched)) {
-    if (!file) continue
-    const loaded = readCursor(join(dir, file))
-    if (loaded) cursors[state] = loaded
-  }
-
-  return { status: 'loaded', cursors, states }
-}
-
-function readCursor(path: string): Cursor | undefined {
-  let bytes: Uint8Array
-  try {
-    bytes = readFileSync(path)
-  } catch {
-    return undefined
-  }
-
-  const hotspot = cursorHotspot(bytes)
-  if (!hotspot) return undefined
-
-  return {
-    image: `data:${CURSOR_MIME};base64,${Buffer.from(bytes).toString('base64')}`,
-    hotspot,
-  }
-}
-
-function readdirNames(dir: string): string[] {
-  return readdirSync(dir, { withFileTypes: true })
-    .filter((entry) => entry.isFile())
-    .map((entry) => entry.name)
-}
-
-function message(error: unknown): string {
-  return error instanceof Error ? error.message : String(error)
-}

package/src/demo/timeline.ts

@@ -1,64 +0,0 @@
-import { mkdirSync, writeFileSync } from 'node:fs'
-import { basename, dirname, extname, join } from 'node:path'
-import type { DemoStep } from '@/demo/compile'
-
-/**
- * A step's target in viewport pixels, which are the video frame's own
- * coordinates because the recording is sized to the viewport.
- */
-export interface TargetBox {
-  readonly x: number
-  readonly y: number
-  readonly width: number
-  readonly height: number
-}
-
-/** One step as the run clocked it, in wall-clock milliseconds. */
-export interface StepTiming {
-  readonly index: number
-  readonly kind: DemoStep['kind']
-  readonly startedAt: number
-  readonly endedAt: number
-  readonly box?: TargetBox
-}
-
-/**
- * Times count from the recording's start rather than the first step, since
- * that is the clock a composition places the take on. A step ends once its
- * hold has played, so the span covers what the viewer sees of it.
- */
-export interface TimelineEntry {
-  readonly index: number
-  readonly kind: DemoStep['kind']
-  readonly startMs: number
-  readonly endMs: number
-  readonly box?: TargetBox
-}
-
-export function timelineEntry(
-  timing: StepTiming,
-  recordingStart: number,
-): TimelineEntry {
-  return {
-    index: timing.index,
-    kind: timing.kind,
-    startMs: Math.round(timing.startedAt - recordingStart),
-    endMs: Math.round(timing.endedAt - recordingStart),
-    ...(timing.box ? { box: timing.box } : {}),
-  }
-}
-
-export function timelinePath(videoPath: string): string {
-  return join(
-    dirname(videoPath),
-    `${basename(videoPath, extname(videoPath))}.timeline.json`,
-  )
-}
-
-export function writeTimeline(
-  path: string,
-  entries: readonly TimelineEntry[],
-): void {
-  mkdirSync(dirname(path), { recursive: true })
-  writeFileSync(path, `${JSON.stringify({ entries }, null, 2)}\n`)
-}

package/src/slides/convert/chart.ts

@@ -1,165 +0,0 @@
-import type PptxGenJS from 'pptxgenjs'
-import { position, type Rect } from '@/slides/convert/shapes'
-
-/**
- * A `<figure data-chart="...">` holding a `<table>` lands as a native chart.
- * The table stays the page's accessible source and is not also drawn. Its
- * header row names the series and its first column names the categories.
- */
-
-export const CHART_TYPES = ['bar', 'line', 'area', 'pie', 'doughnut'] as const
-export type ChartType = (typeof CHART_TYPES)[number]
-
-export interface ChartRecord {
-  readonly selector: string
-  readonly box: Rect
-  /** The raw `data-chart` value, checked against `CHART_TYPES` here. */
-  readonly type: string
-  readonly hasLabels: boolean
-  /** The figure's `<figcaption>`, when it has one. */
-  readonly title?: string
-  readonly rows: readonly (readonly string[])[]
-}
-
-export interface ChartTheme {
-  /** Series colors in order, repeated past the last. */
-  readonly colors: readonly string[]
-  readonly ink: string
-  readonly muted: string
-  readonly face: string
-}
-
-export interface ChartSeries {
-  readonly name: string
-  readonly labels: readonly string[]
-  /** `null` is an empty cell, which the chart draws as a gap. */
-  readonly values: readonly (number | null)[]
-}
-
-export type ChartPlan =
-  | {
-      readonly status: 'chart'
-      readonly type: ChartType
-      readonly data: readonly ChartSeries[]
-      readonly options: PptxGenJS.IChartOpts
-    }
-  | {
-      readonly status: 'refused'
-      readonly selector: string
-      readonly message: string
-    }
-
-export interface ColorRole {
-  readonly name: string
-  readonly hex: string
-}
-
-/** The grounds a series would vanish into. */
-const GROUND_ROLES = new Set(['--color-background', '--color-surface'])
-
-const NUMBER = /^-?(\d+\.?\d*|\.\d+)$/
-
-/**
- * A comma counts as a thousands separator only where it groups in threes, so a
- * comma-decimal `3,5` refuses rather than reading as 35.
- */
-const GROUPED = /^-?\d{1,3}(,\d{3})+(\.\d+)?$/
-
-const isChartType = (value: string): value is ChartType =>
-  (CHART_TYPES as readonly string[]).includes(value)
-
-/**
- * The accent, then every other declared color role in token order except the
- * grounds, each color once. No project declares a chart palette, so the
- * project's own roles stand in for one.
- */
-export function seriesColors(
-  accent: string,
-  roles: readonly ColorRole[],
-): string[] {
-  const colors = [accent]
-  for (const role of roles) {
-    if (GROUND_ROLES.has(role.name) || colors.includes(role.hex)) continue
-    colors.push(role.hex)
-  }
-  return colors
-}
-
-function cycle(colors: readonly string[], count: number): string[] {
-  return Array.from(
-    { length: count },
-    (_, index) => colors[index % colors.length] ?? '',
-  )
-}
-
-export function planChart(record: ChartRecord, theme: ChartTheme): ChartPlan {
-  const refuse = (message: string): ChartPlan => ({
-    status: 'refused',
-    selector: record.selector,
-    message,
-  })
-  if (!isChartType(record.type)) {
-    return refuse(
-      `data-chart "${record.type}" is not one of ${CHART_TYPES.join(', ')}`,
-    )
-  }
-  const [header = [], ...body] = record.rows
-  if (header.length < 2 || body.length === 0) {
-    return refuse(
-      'the table needs a header row and at least one data row of two cells',
-    )
-  }
-
-  const labels = body.map((row) => row[0] ?? '')
-  const data: ChartSeries[] = []
-  for (let column = 1; column < header.length; column += 1) {
-    const values: (number | null)[] = []
-    for (const [index, row] of body.entries()) {
-      const text = (row[column] ?? '').trim()
-      if (text === '') {
-        values.push(null)
-        continue
-      }
-      const bare = GROUPED.test(text) ? text.replace(/,/g, '') : text
-      if (!NUMBER.test(bare)) {
-        return refuse(
-          `cell "${text}" at row ${index + 2}, column ${column + 1} is not a number`,
-        )
-      }
-      values.push(Number(bare))
-    }
-    data.push({ name: header[column] ?? '', labels, values })
-  }
-
-  const isRound = record.type === 'pie' || record.type === 'doughnut'
-  return {
-    status: 'chart',
-    type: record.type,
-    data,
-    options: {
-      ...position(record.box),
-      chartColors: cycle(theme.colors, isRound ? labels.length : data.length),
-      displayBlanksAs: 'gap',
-      showValue: record.hasLabels,
-      dataLabelColor: theme.ink,
-      dataLabelFontFace: theme.face,
-      showLegend: isRound || data.length > 1,
-      legendPos: 'b',
-      legendColor: theme.ink,
-      legendFontFace: theme.face,
-      catAxisLabelColor: theme.muted,
-      catAxisLabelFontFace: theme.face,
-      valAxisLabelColor: theme.muted,
-      valAxisLabelFontFace: theme.face,
-      ...(record.title
-        ? {
-            showTitle: true,
-            title: record.title,
-            titleColor: theme.ink,
-            titleFontFace: theme.face,
-            altText: record.title,
-          }
-        : {}),
-    },
-  }
-}

package/src/slides/convert/deck.ts

@@ -1,244 +0,0 @@
-import { existsSync, readFileSync, realpathSync, statSync } from 'node:fs'
-import { basename, isAbsolute, join, relative, resolve } from 'node:path'
-
-/**
- * What belongs to the deck rather than to one slide, read from `deck.json`
- * beside the slides. A slide overrides a band through attributes on its own
- * `<body>`, which `walk.ts` reads.
- */
-
-export const DECK_FILE = 'deck.json'
-
-export const BAND_SLOTS = ['left', 'center', 'right'] as const
-export type BandSlot = (typeof BAND_SLOTS)[number]
-
-export interface Band {
-  readonly show: boolean
-  readonly left?: string
-  readonly center?: string
-  readonly right?: string
-}
-
-export interface DeckConfig {
-  readonly title: string
-  readonly header: Band
-  readonly footer: Band
-  /** Drawn at the right of the footer, so they show only where it does. */
-  readonly slideNumbers: boolean
-  /** Absolute, resolved against the deck folder. */
-  readonly mark?: string
-  /** The faces the package step embeds, in the order the deck lists them. */
-  readonly fonts: readonly DeckFont[]
-}
-
-export interface DeckFont {
-  readonly family: string
-  readonly weight: number
-  readonly style: 'normal' | 'italic'
-  /** Absolute, resolved against the deck folder and kept inside it. */
-  readonly path: string
-  /** The path as `deck.json` wrote it, which a refusal names. */
-  readonly source: string
-}
-
-export type DeckRead =
-  | { readonly status: 'read'; readonly deck: DeckConfig }
-  | {
-      readonly status: 'refused'
-      readonly field: string
-      readonly message: string
-    }
-
-const DECK_FIELDS = new Set([
-  'title',
-  'header',
-  'footer',
-  'slideNumbers',
-  'mark',
-  'fonts',
-])
-const BAND_FIELDS = new Set<string>(['show', ...BAND_SLOTS])
-const FONT_FIELDS = new Set(['family', 'weight', 'style', 'path'])
-
-class FieldError extends Error {
-  constructor(
-    readonly field: string,
-    message: string,
-  ) {
-    super(message)
-  }
-}
-
-const isRecord = (value: unknown): value is Record<string, unknown> =>
-  typeof value === 'object' && value !== null && !Array.isArray(value)
-
-function rejectUnknown(
-  record: Record<string, unknown>,
-  known: ReadonlySet<string>,
-  prefix: string,
-): void {
-  const unknown = Object.keys(record).find((key) => !known.has(key))
-  if (unknown !== undefined) {
-    throw new FieldError(
-      `${prefix}${unknown}`,
-      `unknown field ${prefix}${unknown}`,
-    )
-  }
-}
-
-function stringField(value: unknown, field: string): string | undefined {
-  if (value === undefined) return undefined
-  if (typeof value !== 'string') {
-    throw new FieldError(field, `${field} must be a string`)
-  }
-  return value
-}
-
-function booleanField(value: unknown, field: string): boolean | undefined {
-  if (value === undefined) return undefined
-  if (typeof value !== 'boolean') {
-    throw new FieldError(field, `${field} must be true or false`)
-  }
-  return value
-}
-
-/**
- * A declared band merges over its default, so `{ "center": "x" }` keeps the
- * footer's title on the left. Declaring any text turns a band on unless it
- * also says `show: false`.
- */
-function band(value: unknown, field: string, fallback: Band): Band {
-  if (value === undefined) return fallback
-  if (!isRecord(value)) {
-    throw new FieldError(field, `${field} must be an object`)
-  }
-  rejectUnknown(value, BAND_FIELDS, `${field}.`)
-  const slots: { -readonly [slot in BandSlot]?: string } = {}
-  for (const slot of BAND_SLOTS) {
-    const text = stringField(value[slot], `${field}.${slot}`)
-    if (text !== undefined) slots[slot] = text
-  }
-  const show =
-    booleanField(value.show, `${field}.show`) ??
-    (Object.keys(slots).length > 0 || fallback.show)
-  return { ...fallback, ...slots, show }
-}
-
-function parse(raw: unknown, folder: string): DeckConfig {
-  if (!isRecord(raw)) {
-    throw new FieldError(DECK_FILE, `${DECK_FILE} must hold an object`)
-  }
-  rejectUnknown(raw, DECK_FIELDS, '')
-  const title = stringField(raw.title, 'title') ?? basename(folder)
-  const header = band(raw.header, 'header', { show: false })
-  const footer = band(raw.footer, 'footer', { show: true, left: title })
-  const slideNumbers = booleanField(raw.slideNumbers, 'slideNumbers') ?? true
-  if (slideNumbers && footer.right !== undefined) {
-    throw new FieldError(
-      'footer.right',
-      'footer.right is where slide numbers sit. Set slideNumbers to false to use it',
-    )
-  }
-  const markPath = stringField(raw.mark, 'mark')
-  let mark: string | undefined
-  if (markPath !== undefined) {
-    mark = join(folder, markPath)
-    if (!existsSync(mark) || !statSync(mark).isFile()) {
-      throw new FieldError('mark', `mark ${mark} does not exist`)
-    }
-  }
-  const fonts = fontList(raw.fonts, folder)
-  return { title, header, footer, slideNumbers, mark, fonts }
-}
-
-function isWithin(folder: string, path: string): boolean {
-  const inside = relative(folder, path)
-  return inside !== '' && !inside.startsWith('..') && !isAbsolute(inside)
-}
-
-/**
- * A face is read from the deck folder only, so a `deck.json` cannot point the
- * export at a file elsewhere on the machine and carry it out inside the deck.
- */
-function fontList(value: unknown, folder: string): DeckFont[] {
-  if (value === undefined) return []
-  if (!Array.isArray(value)) {
-    throw new FieldError('fonts', 'fonts must be a list')
-  }
-  return value.map((entry: unknown, index): DeckFont => {
-    const field = `fonts[${index}]`
-    if (!isRecord(entry)) {
-      throw new FieldError(field, `${field} must be an object`)
-    }
-    rejectUnknown(entry, FONT_FIELDS, `${field}.`)
-    const family = stringField(entry.family, `${field}.family`)
-    if (!family) {
-      throw new FieldError(`${field}.family`, `${field}.family is required`)
-    }
-    const weight = entry.weight ?? 400
-    if (
-      typeof weight !== 'number' ||
-      !Number.isInteger(weight) ||
-      weight < 1 ||
-      weight > 1000
-    ) {
-      throw new FieldError(
-        `${field}.weight`,
-        `${field}.weight must be a whole number from 1 to 1000`,
-      )
-    }
-    const style = entry.style ?? 'normal'
-    if (style !== 'normal' && style !== 'italic') {
-      throw new FieldError(
-        `${field}.style`,
-        `${field}.style must be normal or italic`,
-      )
-    }
-    const source = stringField(entry.path, `${field}.path`)
-    if (!source) {
-      throw new FieldError(`${field}.path`, `${field}.path is required`)
-    }
-    const path = resolve(folder, source)
-    const outside = new FieldError(
-      `${field}.path`,
-      `${field}.path ${source} lies outside the deck folder`,
-    )
-    if (!isWithin(folder, path)) throw outside
-    if (!existsSync(path) || !statSync(path).isFile()) {
-      throw new FieldError(
-        `${field}.path`,
-        `${field}.path ${path} does not exist`,
-      )
-    }
-    // A link inside the folder can still lead out of it.
-    if (!isWithin(realpathSync(folder), realpathSync(path))) throw outside
-    return { family, weight, style, path, source }
-  })
-}
-
-export function readDeck(folder: string): DeckRead {
-  const path = join(folder, DECK_FILE)
-  let raw: unknown = {}
-  if (existsSync(path)) {
-    try {
-      raw = JSON.parse(readFileSync(path, 'utf8'))
-    } catch (error) {
-      const reason = error instanceof Error ? error.message : String(error)
-      return {
-        status: 'refused',
-        field: DECK_FILE,
-        message: `${path}: not valid JSON (${reason})`,
-      }
-    }
-  }
-  try {
-    return { status: 'read', deck: parse(raw, folder) }
-  } catch (error) {
-    if (!(error instanceof FieldError)) throw error
-    return {
-      status: 'refused',
-      field: error.field,
-      message: `${path}: ${error.message}`,
-    }
-  }
-}