@revealui/core 0.0.1-pre.0

package/dist/core/observability/metrics.ts

@@ -0,0 +1,156 @@
+/**
+ * Metrics Collection System
+ * Collects and exports application metrics for monitoring
+ */
+
+export interface Metric {
+  name: string
+  value: number
+  timestamp: number
+  tags?: Record<string, string>
+}
+
+export interface CounterMetric extends Metric {
+  type: "counter"
+}
+
+export interface GaugeMetric extends Metric {
+  type: "gauge"
+}
+
+export interface HistogramMetric extends Metric {
+  type: "histogram"
+  buckets?: number[]
+}
+
+class MetricsCollector {
+  private metrics: Metric[] = []
+  private counters: Map<string, number> = new Map()
+  private gauges: Map<string, number> = new Map()
+
+  /**
+   * Increment a counter metric
+   */
+  increment(name: string, value: number = 1, tags?: Record<string, string>): void {
+    const current = this.counters.get(name) || 0
+    const newValue = current + value
+    this.counters.set(name, newValue)
+
+    const metric: CounterMetric = {
+      name,
+      value: newValue,
+      timestamp: Date.now(),
+      type: "counter",
+      tags,
+    }
+
+    this.metrics.push(metric)
+    this.exportMetric(metric)
+  }
+
+  /**
+   * Set a gauge metric
+   */
+  gauge(name: string, value: number, tags?: Record<string, string>): void {
+    this.gauges.set(name, value)
+
+    const metric: GaugeMetric = {
+      name,
+      value,
+      timestamp: Date.now(),
+      type: "gauge",
+      tags,
+    }
+
+    this.metrics.push(metric)
+    this.exportMetric(metric)
+  }
+
+  /**
+   * Record a histogram metric
+   */
+  histogram(
+    name: string,
+    value: number,
+    buckets?: number[],
+    tags?: Record<string, string>
+  ): void {
+    const metric: HistogramMetric = {
+      name,
+      value,
+      timestamp: Date.now(),
+      type: "histogram",
+      buckets,
+      tags,
+    }
+
+    this.metrics.push(metric)
+    this.exportMetric(metric)
+  }
+
+  /**
+   * Export metric (in production, this would send to metrics service)
+   */
+  private exportMetric(metric: Metric): void {
+    if (process.env.NODE_ENV === "production") {
+      // In production, send to metrics service (e.g., Datadog, Prometheus)
+      // For now, log as JSON
+      if (process.env.METRICS_ENABLED === "true") {
+        console.log(JSON.stringify({ type: "metric", ...metric }))
+      }
+    } else {
+      // In development, log formatted
+      console.log(`[METRIC] ${metric.name}=${metric.value}`, metric.tags || {})
+    }
+  }
+
+  /**
+   * Get all metrics
+   */
+  getMetrics(): Metric[] {
+    return [...this.metrics]
+  }
+
+  /**
+   * Get current counter value
+   */
+  getCounter(name: string): number {
+    return this.counters.get(name) || 0
+  }
+
+  /**
+   * Get current gauge value
+   */
+  getGauge(name: string): number {
+    return this.gauges.get(name) || 0
+  }
+
+  /**
+   * Clear all metrics
+   */
+  clear(): void {
+    this.metrics = []
+    this.counters.clear()
+    this.gauges.clear()
+  }
+}
+
+// Export singleton instance
+export const metrics = new MetricsCollector()
+
+/**
+ * Common metric names
+ */
+export const MetricNames = {
+  HTTP_REQUESTS: "http.requests",
+  HTTP_REQUEST_DURATION: "http.request.duration",
+  HTTP_ERRORS: "http.errors",
+  DATABASE_QUERIES: "database.queries",
+  DATABASE_QUERY_DURATION: "database.query.duration",
+  CACHE_HITS: "cache.hits",
+  CACHE_MISSES: "cache.misses",
+  ACTIVE_CONNECTIONS: "active.connections",
+  MEMORY_USAGE: "memory.usage",
+  CPU_USAGE: "cpu.usage",
+} as const
+

package/dist/core/processing/getters/getAssertErrMsg.ts

@@ -0,0 +1,49 @@
+import { removeErrMsg } from "../../gaurds/errors/removeErrMsg";
+import { isObject } from "../../gaurds/validators/isObject";
+import { globalObject } from "../../globals/objects/log";
+import { projectTag } from "../../globals/tags/projectTag";
+import { projectTagWithVersion } from "../../globals/tags/projectTagWithVersion";
+
+export { getAssertErrMsg };
+
+function getAssertErrMsg(
+  thing: unknown,
+): { assertMsg: string; showRevealVersion: boolean } | null {
+  let errMsg: string;
+  let errStack: null | string = null;
+  if (typeof thing === "string") {
+    errMsg = thing;
+  } else if (
+    isObject(thing) &&
+    typeof thing.message === "string" &&
+    typeof thing.stack === "string"
+  ) {
+    errMsg = thing.message;
+    errStack = thing.stack;
+  } else {
+    return null;
+  }
+
+  let assertMsg: string;
+  let isBug: boolean;
+  if (errMsg.startsWith(projectTag)) {
+    assertMsg = errMsg.slice(projectTag.length);
+    isBug = false;
+  } else if (errMsg.startsWith(projectTagWithVersion)) {
+    assertMsg = errMsg.slice(projectTagWithVersion.length);
+    isBug = true;
+  } else {
+    return null;
+  }
+
+  // Append stack trace
+  if (
+    errStack &&
+    (isBug || globalObject.showStackTraceList.has(thing as any))
+  ) {
+    assertMsg = `${assertMsg}\n${removeErrMsg(errStack)}`;
+  }
+
+  const showRevealVersion = isBug;
+  return { assertMsg, showRevealVersion };
+}

package/dist/core/processing/getters/getAssetsDir.ts

@@ -0,0 +1,11 @@
+export { getAssetsDir };
+
+import type { ResolvedConfig } from "vite";
+import { assertUsage } from "../../../plugins/utils.js";
+
+function getAssetsDir(config: ResolvedConfig) {
+  let { assetsDir } = config.build;
+  assertUsage(assetsDir, `${assetsDir} cannot be an empty string`);
+  assetsDir = assetsDir.split(/\/|\\/).filter(Boolean).join("/");
+  return assetsDir;
+}

package/dist/core/processing/getters/getBaseServer.ts

@@ -0,0 +1,16 @@
+import { assert } from "../../gaurds/assertions/assert";
+
+export { getBaseServer };
+
+// import { assert } from "../server-routing-runtime/utils.js";
+
+function getBaseServer(): string {
+  // @ts-ignore Since dist/cjs/client/ is never used, we can ignore this error.
+  const baseServer: string = import.meta.env.BASE_SERVER;
+  assert(isBaseServer(baseServer));
+  return baseServer;
+}
+// We don't use isBaseServer() defined in utils/parseUrl.ts to avoid loading the whole file in the browser
+function isBaseServer(baseServer: string): boolean {
+  return baseServer.startsWith("/");
+}

package/dist/core/processing/getters/getCacheControl.ts

@@ -0,0 +1,26 @@
+export { getCacheControl }
+
+import type { PageConfigRuntime } from "../../../types/interfaces/page.js"
+import { getConfigValueRuntime } from "./getConfigValue.js"
+import { getPageConfig } from "./getPageConfig.js"
+
+const defaultValue = "no-store, max-age=0"
+
+function getCacheControl(
+  pageId: string,
+  pageConfigs: PageConfigRuntime[]
+): string {
+  const pageConfig = getPageConfig(pageId, pageConfigs)
+  const configValue = getConfigValueRuntime(
+    pageConfig,
+    "cacheControl",
+    "string"
+  )
+  const value = configValue?.value
+  if (value) return value
+
+  // - Disabling caching by default is the safest strategy, because caching is problematic with authentication as described in https://github.com/revealjs/reveal/issues/1275#issuecomment-1824366875
+  // - Are there use cases when we don't need to disable caching?
+  //   - When there isn't any <script id="reveal_pageContext" type="application/json"> then we can safely have caching. (We don't implement this exception because we're lazy and it's quite a rare situation.)
+  return defaultValue
+}

package/dist/core/processing/getters/getConfigDefinedAt.ts

@@ -0,0 +1,73 @@
+export { getConfigDefinedAt, getConfigDefinedAtOptional, getDefinedAtString };
+export type { ConfigDefinedAt, ConfigDefinedAtOptional };
+
+import pc from "@brillout/picocolors";
+
+import type {
+  DefinedAtData,
+  DefinedAtFile,
+} from "../../../types/interfaces/page.js";
+import { assert } from "../../gaurds/assertions/assert/index.js";
+import { isArray } from "../../gaurds/validators/isArray.js";
+import { getExportPath } from "./getExportPath.js";
+
+type ConfigDefinedAtOptional =
+  | ConfigDefinedAt
+  | `Config ${string} defined internally`;
+type ConfigDefinedAt = `Config ${string} defined at ${string}`;
+
+function getConfigDefinedAt<
+  SentenceBegin extends "Config" | "config" /*| 'Hook'*/,
+  ConfigName extends string,
+>(
+  sentenceBegin: SentenceBegin,
+  configName: ConfigName,
+  definedAtData: DefinedAtFile | DefinedAtFile[],
+): `${SentenceBegin} ${ConfigName} defined at ${string}` {
+  return `${begin(sentenceBegin, configName)} at ${getDefinedAtString(definedAtData, configName)}`;
+}
+function getConfigDefinedAtOptional<
+  SentenceBegin extends "Config" | "config" /*| 'Hook'*/,
+  ConfigName extends string,
+>(
+  sentenceBegin: SentenceBegin,
+  configName: ConfigName,
+  definedAtData: DefinedAtData,
+): `${SentenceBegin} ${ConfigName} defined ${"internally" | `at ${string}`}` {
+  if (!definedAtData) {
+    return `${begin(sentenceBegin, configName)} internally`;
+  } else {
+    return `${begin(sentenceBegin, configName)} at ${getDefinedAtString(definedAtData, configName)}`;
+  }
+}
+function begin<ConfigName extends string, SentenceBegin extends string>(
+  sentenceBegin: SentenceBegin,
+  configName: ConfigName,
+) {
+  return `${sentenceBegin} ${pc.cyan(configName)} defined` as const;
+}
+
+function getDefinedAtString(
+  definedAtData: DefinedAtFile | DefinedAtFile[],
+  configName: string,
+): string {
+  let files: DefinedAtFile[];
+  if (isArray(definedAtData)) {
+    files = definedAtData;
+  } else {
+    files = [definedAtData];
+  }
+  assert(files.length >= 1);
+  const definedAtString = files
+    .map((source) => {
+      const { filePathToShowToUser, fileExportPathToShowToUser } = source;
+      let s = filePathToShowToUser;
+      const exportPath = getExportPath(fileExportPathToShowToUser, configName);
+      if (exportPath) {
+        s = `${s} > ${pc.cyan(exportPath)}`;
+      }
+      return s;
+    })
+    .join(" / ");
+  return definedAtString;
+}

package/dist/core/processing/getters/getConfigReveal.ts

@@ -0,0 +1,14 @@
+export { getConfigReveal };
+
+import { ResolvedConfig } from "vite";
+import type { ConfigRevealResolved } from "../../../types/interfaces/reveal.js";
+import { assert } from "../../gaurds/assertions/assert/index.js";
+
+async function getConfigReveal(
+  config: ResolvedConfig,
+): Promise<ConfigRevealResolved> {
+  const { configRevealPromise } = config as any;
+  assert(configRevealPromise);
+  const configReveal: ConfigRevealResolved = await configRevealPromise;
+  return configReveal;
+}

package/dist/core/processing/getters/getConfigValue.ts

@@ -0,0 +1,68 @@
+export { getConfigValueRuntime, getConfigValueTyped };
+export type { TypeAsString };
+
+import pc from "@brillout/picocolors";
+import type { ConfigNameBuiltIn } from "../../../types/interfaces/config.js";
+import type {
+  ConfigValue,
+  DefinedAtData,
+  PageConfigRuntime,
+} from "../../../types/interfaces/page.js";
+
+import { getConfigDefinedAtOptional } from "./getConfigDefinedAt.js";
+import { ResolveTypeAsString } from "../../gaurds/validators/hasProp.js";
+import { assert } from "../../gaurds/assertions/assert/index.js";
+import { getValuePrintable } from "./getValuePrintable.js";
+import { assertUsage } from "../../gaurds/assertions/assertUsage/index.js";
+type ConfigName = ConfigNameBuiltIn;
+type TypeAsString = "string" | "boolean" | undefined;
+
+function getConfigValueTyped<Type extends TypeAsString = undefined>(
+  configValue: ConfigValue,
+  configName: ConfigName,
+  type?: Type,
+): null | (ConfigValue & { value: ResolveTypeAsString<Type> }) {
+  /* [NULL_HANDLING] Do we really need this? This doesn't seem to make sense, let's eventually (re)move this.
+  // Enable users to suppress global config values by setting the local config value to null
+  if (configValue.value === null) return null
+  */
+  const { value, definedAtData } = configValue;
+  if (type) assertConfigValueType(value, type, configName, definedAtData);
+  return configValue as ConfigValue & { value: ResolveTypeAsString<Type> };
+}
+
+function getConfigValueRuntime<Type extends TypeAsString = undefined>(
+  pageConfig: PageConfigRuntime,
+  configName: ConfigName,
+  type?: Type,
+): null | (ConfigValue & { value: ResolveTypeAsString<Type> }) {
+  const configValue = pageConfig.configValues[configName];
+  if (!configValue) return null;
+  return getConfigValueTyped(configValue, configName, type);
+}
+
+function assertConfigValueType(
+  value: unknown,
+  type: "string" | "boolean",
+  configName: string,
+  definedAtData: DefinedAtData,
+) {
+  assert(value !== null);
+  const typeActual = typeof value;
+  if (typeActual === type) return;
+  const valuePrintable = getValuePrintable(value);
+  const problem: string =
+    valuePrintable !== null
+      ? (`value ${pc.cyan(valuePrintable)}` as const)
+      : (`type ${pc.cyan(typeActual) as string}` as const);
+  const configDefinedAt = getConfigDefinedAtOptional(
+    "Config",
+    configName,
+    definedAtData,
+  );
+  const errMsg =
+    `${configDefinedAt} has an invalid ${problem}: it should be a ${
+      pc.cyan(type) as string
+    } instead` as const;
+  assertUsage(false, errMsg);
+}

package/dist/core/processing/getters/getConfigValueBuildTime.ts

@@ -0,0 +1,92 @@
+export { getConfigValueBuildTime };
+
+import type { ConfigNameBuiltIn } from "../../../types/interfaces/config.js";
+import type {
+  ConfigValue,
+  ConfigValueSource,
+  DefinedAtFile,
+  PageConfigBuildTime,
+} from "../../../types/interfaces/page.js";
+import { assert } from "../../gaurds/assertions/assert/index.js";
+import { assertIsNotProductionRuntime } from "../../gaurds/assertions/assertIsNotProductionRuntime/index.js";
+import { ResolveTypeAsString } from "../../gaurds/validators/hasProp.js";
+
+import { getConfigValueTyped, type TypeAsString } from "./getConfigValue.js";
+assertIsNotProductionRuntime();
+type ConfigName = ConfigNameBuiltIn;
+
+function getConfigValueBuildTime<Type extends TypeAsString = undefined>(
+  pageConfig: PageConfigBuildTime,
+  configName: ConfigName,
+  type?: Type,
+): null | (ConfigValue & { value: ResolveTypeAsString<Type> }) {
+  const configValue = getConfigValue(pageConfig, configName);
+  if (!configValue) return null;
+  return getConfigValueTyped(configValue, configName, type);
+}
+
+function getConfigValue(
+  pageConfig: PageConfigBuildTime,
+  configName: ConfigName,
+): null | ConfigValue {
+  const { configValueSources, configValuesComputed, configDefinitions } =
+    pageConfig;
+
+  const configValueComputed = configValuesComputed[configName];
+  if (configValueComputed) {
+    return {
+      type: "computed",
+      value: configValueComputed.value,
+      definedAtData: null,
+    };
+  }
+
+  const sources = configValueSources[configName];
+  if (!sources) return null;
+  const configDef = configDefinitions[configName];
+  assert(configDef);
+  if (!configDef.cumulative) {
+    const configValueSource = sources[0];
+    assert(configValueSource);
+    assert(configValueSource.isOverriden === false);
+    assert(sources.slice(1).every((s) => s.isOverriden === true));
+    assert("value" in configValueSource);
+    return {
+      type: "standard",
+      value: configValueSource.value,
+      definedAtData: getDefinedAtFile(configValueSource),
+    };
+  } else {
+    const { value, definedAtData } = mergeCumulative(sources);
+    assert(value.length === definedAtData.length);
+    return {
+      type: "cumulative",
+      value,
+      definedAtData,
+    };
+  }
+}
+
+function mergeCumulative(configValueSources: ConfigValueSource[]) {
+  const value: unknown[] = [];
+  const definedAtData: DefinedAtFile[] = [];
+  configValueSources.forEach((configValueSource) => {
+    assert(configValueSource.isOverriden === false);
+
+    assert(configValueSource.configEnv.config === true);
+    assert("value" in configValueSource);
+
+    value.push(configValueSource.value);
+    definedAtData.push(getDefinedAtFile(configValueSource));
+  });
+  return { value, definedAtData };
+}
+
+function getDefinedAtFile(configValueSource: ConfigValueSource): DefinedAtFile {
+  return {
+    filePathToShowToUser:
+      configValueSource.definedAtFilePath.filePathToShowToUser,
+    fileExportPathToShowToUser:
+      configValueSource.definedAtFilePath.fileExportPathToShowToUser,
+  };
+}

package/dist/core/processing/getters/getConfigValueFilePathToShowToUser.ts

@@ -0,0 +1,17 @@
+import { DefinedAtData } from "../../../types/interfaces/page";
+import { assert } from "../../gaurds/assertions/assert";
+import { isArray } from "../../gaurds/validators/isArray";
+
+export { getConfigValueFilePathToShowToUser };
+
+function getConfigValueFilePathToShowToUser(
+  definedAtData: DefinedAtData,
+): null | string {
+  // A unique file path only exists if the config value isn't cumulative nor computed:
+  //  - cumulative config values have multiple file paths
+  //  - computed values don't have any file path
+  if (!definedAtData || isArray(definedAtData)) return null;
+  const { filePathToShowToUser } = definedAtData;
+  assert(filePathToShowToUser);
+  return filePathToShowToUser;
+}

package/dist/core/processing/getters/getCurrentUrl.ts

@@ -0,0 +1,42 @@
+import { assert } from "../../gaurds/assertions/assert";
+import { parseUrl } from "../../targets/url";
+
+export { getCurrentUrl };
+
+function getCurrentUrl(options?: { withoutHash: true }): string {
+  const url = window.location.href;
+  const { searchOriginal, hashOriginal, pathname } = parseUrl(url, "/");
+  let urlCurrent: string;
+  if (options?.withoutHash) {
+    urlCurrent = `${pathname}${searchOriginal || ""}`;
+  } else {
+    urlCurrent = `${pathname}${searchOriginal || ""}${hashOriginal || ""}`;
+  }
+  assert(urlCurrent.startsWith("/"));
+  return urlCurrent;
+}
+// export default function currentPath(pageContext: {urlPathname: string;}) {
+//   if (typeof window !== "undefined") {
+//     return pageContext.urlPathname
+//   } else {
+//     return "";
+//   }
+// }
+
+// export { getCurrentUrl };
+
+// import { parseUrl } from "./parseUrl.js";
+// import { assert } from "./assert.js";
+
+// function getCurrentUrl(options?: { withoutHash: true }): string {
+//   const url = window.location.href;
+//   const { searchOriginal, hashOriginal, pathname } = parseUrl(url, "/");
+//   let urlCurrent: string;
+//   if (options?.withoutHash) {
+//     urlCurrent = `${pathname}${searchOriginal || ""}`;
+//   } else {
+//     urlCurrent = `${pathname}${searchOriginal || ""}${hashOriginal || ""}`;
+//   }
+//   assert(urlCurrent.startsWith("/"));
+//   return urlCurrent;
+// }

package/dist/core/processing/getters/getEarlyHints.ts

@@ -0,0 +1,58 @@
+export { getEarlyHints }
+export type { EarlyHint }
+
+import { inferEarlyHintLink } from "../../assets/inferHtmlTags.js"
+import { assert } from "../../renderer/stream/utils.js"
+import { PageAsset } from "./getPageAssets.js"
+
+type EarlyHint = PageAsset & {
+  earlyHintLink: string
+}
+
+function getEarlyHints(assets: PageAsset[]): EarlyHint[] {
+  const earlyHints: EarlyHint[] = []
+  {
+    assets.forEach((asset) => {
+      // Don't early hint fallback fonts, https://github.com/revealjs/reveal/issues/624
+      if (isFontFallback(asset, earlyHints)) return
+      earlyHints.push({
+        ...asset,
+        earlyHintLink: inferEarlyHintLink(asset),
+      })
+    })
+  }
+  return earlyHints
+}
+function isFontFallback(asset: PageAsset, earlyHints: EarlyHint[]): boolean {
+  if (asset.assetType !== "font") {
+    return false
+  }
+  const fontUrlBase = removeFileExtentionAndHash(asset.src)
+  return earlyHints.some((hint) => {
+    return (
+      hint.assetType === "font" &&
+      removeFileExtentionAndHash(hint.src) === fontUrlBase
+    )
+  })
+}
+function removeFileExtentionAndHash(assetUrl: string): string {
+  assert(!assetUrl.includes("\\"))
+
+  // The logic below doesn't work for '/assets/chunk-0e184ced.js'
+  assert(!assetUrl.endsWith(".js"))
+
+  const paths = assetUrl.split("/")
+  {
+    const filename = paths[paths.length - 1]!
+    const filenameParts = filename.split(".")
+    assert(filenameParts.length >= 2)
+    // User may set config.build.rollupOptions.output.assetFileNames => we can't assume the filename to be `*.${hash}.${ext}`
+    const filenameBase = filenameParts.slice(
+      0,
+      filenameParts.length === 2 ? -1 : -2
+    )
+    assert(filenameBase.length >= 1)
+    paths[paths.length - 1] = filenameBase.join(".")
+  }
+  return paths.join("/")
+}

package/dist/core/processing/getters/getEnv.ts

@@ -0,0 +1,33 @@
+const getEnv = (key: string): string | undefined => {
+  let value;
+
+  // Attempt to fetch Vite-specific environment variables
+  try {
+    value = import.meta.env[`VITE_${key}`];
+    if (typeof value === "string") return value;
+  } catch (error) {
+    console.error("import.meta.env is not accessible:", error);
+  }
+
+  // Attempt to fetch Next.js-specific environment variables
+  try {
+    value = process.env[`NEXT_PUBLIC_${key}`];
+    if (typeof value === "string") return value;
+  } catch (error) {
+    console.error("process.env is not accessible:", error);
+  }
+
+  // Attempt to fetch server-side and general environment variables (without public prefixes)
+  try {
+    value = process.env[key];
+    if (typeof value === "string") return value;
+  } catch (error) {
+    console.error("Accessing general environment variables failed:", error);
+  }
+
+  // Log a warning if the environment variable is not found
+  console.warn(`Environment variable ${key} is not defined.`);
+  return undefined;
+};
+
+export default getEnv;

package/dist/core/processing/getters/getErrorPageId.ts

@@ -0,0 +1,23 @@
+
+import { PageConfigRuntime } from "../../../types/interfaces/page"
+import {PageFile} from "../../__internal"
+import { assertUsage } from "../../gaurds/assertions/assertUsage"
+
+export { getErrorPageId }
+
+function getErrorPageId(
+  pageFilesAll: PageFile[],
+  pageConfigs: PageConfigRuntime[]
+): string | null {
+  if (pageConfigs.length > 0) {
+    const errorPageConfigs = pageConfigs.filter((p) => p.isErrorPage)
+    if (errorPageConfigs.length === 0) return null
+    assertUsage(
+      errorPageConfigs.length === 1,
+      "Only one error page can be defined"
+    )
+    return errorPageConfigs[0]!.pageId
+  }
+
+  return null
+}