@rr0/cms 0.1.2 → 0.1.3

package/time/EventReplacerFactory.ts

@@ -1,45 +0,0 @@
-import { DomReplacer, ReplacerFactory } from "ssg-api"
-import { HtmlRR0SsgContext } from "../RR0SsgContext"
-import { AllDataService } from "../data"
-import { EventRenderer } from "./EventRenderer"
-import { RR0Event } from "../event"
-
-export class EventReplacer<D extends RR0Event> {
-
-  constructor(protected renderer: EventRenderer<D>, protected dataService: AllDataService) {
-  }
-
-  async replacement(context: HtmlRR0SsgContext, original: HTMLElement): Promise<HTMLElement> {
-    const outputDoc = context.file.document
-    const replacement = outputDoc.createElement("span")
-    const href = (original as HTMLAnchorElement).href || original.dataset.href
-    await this.sourceFromFile(context, replacement, href)
-    return replacement
-  }
-
-  protected async sourceFromFile(context: HtmlRR0SsgContext, container: HTMLElement, href: string) {
-    const data = await this.dataService.getFromDir<D>(href, ["sighting"], ["index.json"])
-    if (data.length <= 0) {
-      throw new Error("Could not find metadata in " + href)
-    }
-    await this.renderer.render(context, data[0], container)
-  }
-}
-
-/**
- * Creates replacers for sources HTML in a given context.
- */
-export class EventReplacerFactory<D extends RR0Event> implements ReplacerFactory<DomReplacer> {
-
-  constructor(protected replacer: EventReplacer<D>) {
-  }
-
-  async create(context: HtmlRR0SsgContext): Promise<DomReplacer> {
-    const replacer = this.replacer
-    return {
-      async replace(original: HTMLElement): Promise<HTMLElement> {
-        return replacer.replacement(context, original)
-      }
-    }
-  }
-}

package/time/RelativeTimeTextBuilder.ts

@@ -1,174 +0,0 @@
-import { TimeTextBuilder } from "./TimeTextBuilder"
-import { RR0SsgContext } from "../RR0SsgContext"
-
-export class RelativeTimeTextBuilder {
-
-  constructor(protected timeTextBuilder: TimeTextBuilder) {
-  }
-
-  build(oldContext: RR0SsgContext, newContext: RR0SsgContext): string {
-    const previousTime = oldContext?.time
-    if (!previousTime?.isDefined()) {
-      return this.timeTextBuilder.build(newContext)
-    }
-    const deltaContext = oldContext.clone()
-    const deltaTime = deltaContext.time
-    let dayOfMonthDelta: number | undefined
-    let yearDelta: number | undefined
-    let monthDelta: number | undefined
-    let hourDelta: number | undefined
-    let minutesDelta: number | undefined
-
-    function shouldSetDay() {
-      return !previousTime.getMonth() || monthDelta === 0
-    }
-
-    function shouldSetHour() {
-      return !previousTime.getDayOfMonth() || dayOfMonthDelta === 0
-    }
-
-    function shouldSetMinutes() {
-      return !previousTime.getMinutes() || hourDelta === 0
-    }
-
-    function setYear(year: number) {
-      const previousYear = previousTime.getYear()
-      if (previousYear) {
-        yearDelta = year - previousYear
-        if (yearDelta != 0) {
-          deltaTime.setYear(year)
-        }
-      }
-    }
-
-    function setMonth(month: number) {
-      const previousMonth = previousTime.getMonth()
-      if (yearDelta === 0) {
-        monthDelta = month - (previousMonth || 0)
-        if (monthDelta != 0) {
-          deltaTime.setMonth(month)
-        }
-      } else if (yearDelta != 0) {
-        deltaTime.setMonth(month)
-      }
-    }
-
-    function setDayOfMonth(dayOfMonth: number) {
-      const sameMonth = yearDelta === 0 && shouldSetDay()
-      if (sameMonth) {
-        dayOfMonthDelta = dayOfMonth - (previousTime.getDayOfMonth() || 0)
-        if (dayOfMonthDelta != 0) {
-          deltaTime.setDayOfMonth(dayOfMonth)
-        }
-      } else if (monthDelta != 0) {
-        deltaTime.setDayOfMonth(dayOfMonth)
-      }
-    }
-
-    function setHour(hour: number) {
-      const sameDay = yearDelta === 0 && shouldSetDay() && shouldSetHour()
-      if (sameDay) {
-        hourDelta = hour - (previousTime.getHour() || 0)
-        if (hourDelta != 0) {
-          deltaTime.setHour(hour)
-        }
-      } else if (dayOfMonthDelta != 0) {
-        deltaTime.setHour(hour)
-      }
-    }
-
-    function setMinutes(minutes: number) {
-      const sameHour = yearDelta === 0 && shouldSetDay() && shouldSetHour() && shouldSetMinutes()
-      if (sameHour) {
-        minutesDelta = minutes - (previousTime.getMinutes() || 0)
-        if (minutesDelta != 0) {
-          deltaTime.setMinutes(minutes)
-        }
-      }
-      deltaTime.setMinutes(minutes)
-    }
-
-    const time = newContext.time
-    const year = time.getYear()
-    if (year) {
-      setYear(year)
-    }
-    const month = time.getMonth()
-    if (month) {
-      setMonth(month)
-    }
-    const dayOfMonth = time.getDayOfMonth()
-    if (dayOfMonth) {
-      setDayOfMonth(dayOfMonth)
-    }
-    const hour = time.getHour()
-    if (hour) {
-      setHour(hour)
-    }
-    const minutes = time.getMinutes()
-    if (minutes) {
-      setMinutes(minutes)
-    }
-    let text: string | undefined
-    let messages = newContext.messages.context.time.relative
-    if (dayOfMonthDelta) {
-      switch (dayOfMonthDelta) {
-        case -1:
-          text = messages.day.before
-          break
-        case +1:
-          text = messages.day.after
-          break
-      }
-    } else {
-      if (!dayOfMonth) {
-        switch (monthDelta) {
-          case -1:
-            text = messages.month.before
-            break
-          case +1:
-            text = messages.month.after
-            break
-        }
-      }
-      if (!month) {
-        switch (yearDelta) {
-          case -1:
-            text = messages.year.before
-            break
-          case +1:
-            text = messages.year.after
-            break
-        }
-      }
-      if (!minutes) {
-        switch (hourDelta) {
-          case -1:
-            text = messages.hour.before
-            break
-          case +1:
-            text = messages.hour.after
-            break
-        }
-      }
-    }
-    if (!text) {
-      let print = true
-      let defaultContext: RR0SsgContext
-      if (deltaContext.time.isDefined()) {
-        defaultContext = deltaContext
-        const dayOfMonth = defaultContext.time.getDayOfMonth()
-        if (dayOfMonth && shouldSetDay()) {
-          defaultContext.time.setMonth(newContext.time.getMonth() || previousTime.getMonth(), false)  // give month
-          defaultContext.time.setYear(newContext.time.getYear() || previousTime.getYear(), false)  // give year
-          // context for the day but won't
-          print = false
-        }
-      } else {
-        defaultContext = newContext
-      }
-      text = this.timeTextBuilder.build(defaultContext, print)
-    }
-    return text
-  }
-}

package/time/SsiTitleReplaceCommand.ts

@@ -1,31 +0,0 @@
-import { RegexReplacer, SsiEchoVarReplaceCommand, StringContextHandler } from "ssg-api"
-import { HtmlRR0SsgContext } from "../RR0SsgContext"
-
-/**
- * Replaces the SSI expression "<!--#echo var="title" -->" by the page's <title> content,
- * with a link if there's a <meta name="url"> content.
- */
-export class SsiTitleReplaceCommand extends SsiEchoVarReplaceCommand {
-
-  constructor(protected defaultHandlers: StringContextHandler[] = []) {
-    super("title")
-  }
-
-  protected async createReplacer(context: HtmlRR0SsgContext): Promise<RegexReplacer> {
-    return {
-      replace: (_match: string, ..._args: any[]): string => {
-        const inputFile = context.file
-        let title = inputFile.title
-        if (!title) {
-          this.defaultHandlers.some(handle => !title && (title = handle(context)))
-        }
-        if (!title) {
-          title = inputFile.name
-        }
-        inputFile.title = title
-        const titleUrl = inputFile.meta.url
-        return titleUrl ? `<a href="${titleUrl}" target="_blank">${title}</a>` : title
-      }
-    }
-  }
-}

package/time/Time.ts

@@ -1,41 +0,0 @@
-import { TimeTextBuilder } from "./TimeTextBuilder"
-import { TimeContext } from "./TimeContext"
-import { HtmlRR0SsgContext, RR0SsgContextImpl } from "../RR0SsgContext"
-import { StringUtil } from "../util/string/StringUtil"
-
-export class Time {
-
-  static readonly timePathRegex = /time\/(-)?(\d)\/(\d)\/(\d)\/(\d)\/?(\d{2})?\/?(\d{2})?\/?(index(_[a-z]{2})?.html)?/
-
-  /**
-   * Instantiate a Date object matching an ISO date ("1972-08-12 16:34" for instance).
-   *
-   * Approximated dates like "~1972" will be converted to exact dates ("1972").
-   *
-   * @param isoDate
-   */
-  static dateFromIso(isoDate: string): Date {
-    isoDate = isoDate.replace("~", "")
-    if (isoDate.charAt(0) === "-") {
-      isoDate = "-" + "0".repeat(7 - isoDate.length) + isoDate.substring(1)
-    }
-    return new Date(isoDate)
-  }
-
-  static parseFileName(fileName: string): RegExpExecArray | null {
-    return Time.timePathRegex.exec(fileName)
-  }
-
-  static titleFromFile(context: HtmlRR0SsgContext, fileName: string,
-                       timeTextBuilder: TimeTextBuilder): string | undefined {
-    let title: string | undefined
-    const timeContext = TimeContext.fromFileName(context, fileName)
-    if (timeContext) {
-      const pageContext = new RR0SsgContextImpl(context.locale, timeContext, context.config, context.people,
-        context.file)
-      title = timeTextBuilder.build(pageContext)
-      title = StringUtil.capitalizeFirstLetter(title)
-    }
-    return title
-  }
-}

package/time/TimeContext.ts

@@ -1,303 +0,0 @@
-import { HtmlRR0SsgContext } from "../RR0SsgContext"
-import { Time } from "./Time"
-import { TimeParseResult } from "./TimeReplacer"
-import {
-  Level2Date as EdtfDate,
-  Level2Duration as EdtfDuration,
-  Level2Interval as EdtfInterval,
-  Level2Timeshift
-} from "@rr0/time"
-
-/**
- * Time context for a RR0 page.
- */
-export class TimeContext {
-
-  static readonly dateTimeRegexp = new RegExp(
-    "^(~)?(-?\\d{3,})?(?:-?([0-1]\\d)(?!\:))?(?:-?([0-3]\\d{1,2}(?!\:)))?(?:[T ]?(?:([0-2]\\d):([0-5]\\d))?)?(?: ?([A-Z]{3}))?"
-  )
-  static readonly MINUTE = 60
-  static readonly HOUR = 60 * TimeContext.MINUTE
-  static readonly DAY = 24 * TimeContext.HOUR
-  date: EdtfDate | undefined
-  interval: EdtfInterval | undefined
-  duration: EdtfDuration | undefined
-
-  constructor(
-    _year?: number,
-    _month?: number,
-    _dayOfMonth?: number,
-    _hour?: number,
-    _minutes?: number,
-    _timeZone?: string,
-    approximate: boolean = false,
-    approximateTime: boolean = false,
-    /** @deprecated */
-    from: TimeContext | undefined = undefined,
-    /** @deprecated */
-    to: TimeContext | undefined = undefined,
-    duration: number | undefined = undefined
-  ) {
-    if (from) {
-      this.interval = new EdtfInterval(from?.date, to?.date)
-    } else if (duration) {
-      this.duration = new EdtfDuration(duration)
-    } else {
-      this.date = new EdtfDate(
-        {year: _year, month: _month, day: _dayOfMonth, hour: _hour, minutes: _minutes, timeZone: _timeZone})
-      if (approximate) {
-        this.date.year.approximate = true
-      }
-      if (approximateTime) {
-        if (this.date.hour) {
-          this.date.hour.approximateComponent = true
-        }
-        if (this.date.minutes) {
-          this.date.minutes.approximateComponent = true
-        }
-        if (this.date.seconds) {
-          this.date.seconds.approximateComponent = true
-        }
-      }
-    }
-  }
-
-  get from(): EdtfDate | undefined {
-    return this.interval?.start
-  }
-
-  get to(): EdtfDate | undefined {
-    return this.interval?.end
-  }
-
-  get approximate(): boolean {
-    return this.date?.approximate || this.interval?.approximate || this.duration?.approximate
-  }
-
-  set approximate(approx: boolean) {
-    this.date.approximate = approx
-  }
-
-  get approximateTime(): boolean {
-    return this.approximate || this.date?.hour?.approximate || this.date?.minute?.approximate || this.date?.second?.approximate
-  }
-
-  static parseDateTime(timeStr: string): TimeParseResult {
-    try {
-      const date = EdtfDate.fromString(timeStr)
-      return {
-        approximate: date?.approximate,
-        yearStr: date.year?.toString(),
-        monthStr: date.month?.toString(),
-        dayOfMonthStr: date.day?.toString(),
-        hour: date.hour?.toString(),
-        minutes: date.minutes?.toString(),
-        timeZone: date.timeZone?.toString()
-      }
-    } catch (e) {
-      return undefined
-    }
-  }
-
-  static fromString(timeStr: string): TimeContext {
-    const timeContext = new TimeContext()
-    timeContext.updateFromStr(timeStr)
-    return timeContext
-  }
-
-  static fromDate(date: Date): TimeContext {
-    return new TimeContext(date.getFullYear(), date.getMonth() + 1, date.getDate(), date.getHours(), date.getMinutes(),
-      "UTC" + (date.getTimezoneOffset() < 0 ? "-" : "+") + date.getTimezoneOffset())
-  }
-
-  static fromFileName(context: HtmlRR0SsgContext, fileName = context.file.name): TimeContext | undefined {
-    let timeContext: TimeContext | undefined
-    let elems
-    if (fileName.endsWith("index.html")) {
-      while ((elems = fileName.split("/")).length < 6) {
-        fileName = elems.slice(0, elems.length - 1).join("/") + "/0/index.html"
-      }
-    }
-    const timeExec = Time.parseFileName(fileName)
-    if (timeExec && timeExec.length > 5) {
-      const pageContext = context.clone()
-      timeContext = pageContext.time
-      const m = parseInt(timeExec[2], 10)
-      const c = parseInt(timeExec[3], 10)
-      const d = parseInt(timeExec[4], 10)
-      const u = parseInt(timeExec[5], 10)
-      const year = (timeExec[1] ? -1 : 1) * (m * 1000 + c * 100 + d * 10 + u)
-      timeContext.setYear(year)
-      const monthStr = timeExec[6]
-      timeContext.setMonth(monthStr ? parseInt(monthStr, 10) : undefined)
-      const dayStr = timeExec[7]
-      timeContext.setDayOfMonth(dayStr ? parseInt(dayStr, 10) : undefined)
-      timeContext.setHour(undefined)
-      timeContext.setMinutes(undefined)
-    }
-    return timeContext
-  }
-
-  /**
-   * @param {string} timeStr
-   * @return If the string could be parsed
-   */
-  updateFromStr(timeStr: string) {
-    let valid = Boolean(timeStr)
-    if (valid) {
-      try {
-        this.interval = EdtfInterval.fromString(timeStr)
-        this.date = undefined
-        this.duration = undefined
-      } catch (e) {
-        try {
-          this.duration = EdtfDuration.fromString(timeStr)
-          this.interval = undefined
-          this.date = undefined
-        } catch (e) {
-          try {
-            this.date = EdtfDate.fromString(timeStr)
-            this.duration = undefined
-            this.interval = undefined
-          } catch (e) {
-            console.warn("Could not resolve time string", timeStr, e.message)
-            valid = false
-          }
-        }
-      }
-    }
-    return valid
-  }
-
-  getYear(): number | undefined {
-    return this.date?.year?.value
-  }
-
-  setYear(year: number | undefined, print = true) {
-    if (year != this.date?.year?.value && print) {
-      this.setMonth(undefined, print)
-    }
-    this.date = this.date || new EdtfDate()
-    this.date.year = year
-    return this
-  }
-
-  getMonth(): number | undefined {
-    return this.date?.month?.value
-  }
-
-  setMonth(month: number | undefined, print = true) {
-    if (month != this.date?.month?.value && print) {
-      this.setDayOfMonth(undefined, print)
-    }
-    this.date = this.date || new EdtfDate()
-    this.date.month = month
-    return this
-  }
-
-  getDayOfMonth(): number | undefined {
-    return this.date?.day?.value
-  }
-
-  setDayOfMonth(dayOfMonth: number | undefined, print = true) {
-    if (dayOfMonth != this.date?.day?.value && print) {
-      this.setHour(undefined, print)
-    }
-    this.date = this.date || new EdtfDate()
-    this.date.day = dayOfMonth
-    return this
-  }
-
-  getHour(): number | undefined {
-    return this.date?.hour?.value
-  }
-
-  setHour(hour: number | undefined, print = true) {
-    if (hour != this.date?.hour?.value && print) {
-      this.setMinutes(undefined)
-    }
-    this.date = this.date || new EdtfDate()
-    this.date.hour = hour
-    return this
-  }
-
-  getMinutes(): number | undefined {
-    return this.date?.minute?.value
-  }
-
-  setMinutes(minutes: number | undefined) {
-    this.date = this.date || new EdtfDate()
-    this.date.minute = minutes
-    return this
-  }
-
-  /**
-   * @deprecated
-   */
-  getTimeZone(): string | undefined {
-    return this.date?.timeshift?.toString()
-  }
-
-  getTimeshift(): string | undefined {
-    return this.date?.timeshift?.toString()
-  }
-
-  setTimeZone(timeZone: string | undefined) {
-    this.date = this.date || new Level2Timeshift()
-    try {
-      this.date.timeshift = Level2Timeshift.fromString(timeZone)
-    } catch (e) {
-      console.warn("Could not resolve time zone", timeZone, e.message)
-    }
-    return this
-  }
-
-  isDefined(): boolean {
-    const date = this.date
-    if (!date) {
-      return false
-    }
-    return date.year?.value != undefined
-      || date.month?.value != undefined
-      || date.day?.value != undefined
-      || date.hour?.value != undefined
-      || date.minute?.value != undefined
-  }
-
-  clone(): TimeContext {
-    return new TimeContext(this.date?.year?.value, this.date?.month?.value, this.date?.day?.value,
-      this.date?.hour?.value, this.date?.minutes?.value, this.date?.timeshift?.value,
-      this.approximate, this.approximateTime, this.interval?.from, this.interval?.to, this.duration)
-  }
-
-  reset(): this {
-    this.date = undefined
-    this.interval = undefined
-    this.duration = undefined
-    return this
-  }
-
-  isBefore(other: TimeContext): boolean {
-    return this.toString().localeCompare(other.toString()) < 0
-  }
-
-  isAfter(other: TimeContext): boolean {
-    return this.toString().localeCompare(other.toString()) > 0
-  }
-
-  equals(other: TimeContext): boolean {
-    return this.toString() === other.toString()
-  }
-
-  toString(): string {
-    return this.date ? this.date.toString() : ""
-  }
-
-  toJSON() {
-    return this.toString()
-  }
-
-  protected isSet(value: any) {
-    return value != void 0 && value != null
-  }
-}