@revealui/core 0.0.1-pre.0

package/dist/core/gaurds/assertions/assertSingleInstance/index.ts

@@ -0,0 +1,142 @@
+export {
+  onAssertModuleLoad,
+  onClientEntryClientRouting,
+  onClientEntryServerRouting,
+};
+// TO DO: figure out all places where onAssertModuleLoad needs to be called in repo
+//  - Throw error if there are two different versions of reveal loaded
+//  - Show warning if entry of Client Routing and entry of Server Routing are both loaded
+//  - Show warning if reveal is loaded twice
+
+import pc from "@brillout/picocolors";
+
+import { projectInfo } from "../../../globals/versions/projectInfo";
+import { unique } from "../../../utils/array/unique";
+import getGlobalObject from "../../../processing/getters/getGlobalObject";
+/* Use original assertUsage() & assertWarning() after all CJS is removed from node_modules/reveal/dist/
+import { assertUsage, assertWarning } from './assert.js'
+*/
+const globalObject = getGlobalObject<{
+  instances: string[];
+  checkSingleInstance?: true;
+  isClientRouting?: boolean;
+  // For assertWarning() shim
+  alreadyLogged: Set<string>;
+}>("assertSingleInstance.ts", {
+  instances: [],
+  alreadyLogged: new Set(),
+});
+
+const clientRuntimesClonflict =
+  "Client runtime of both Server Routing and Client Routing loaded https://reveal.dev/client-runtimes-conflict";
+const clientNotSingleInstance =
+  "Client runtime loaded twice https://reveal.dev/client-runtime-duplicated";
+
+function assertSingleInstance() {
+  {
+    const versions = unique(globalObject.instances);
+    assertUsage(
+      versions.length <= 1,
+      // DO *NOT* patch reveal to remove this error: because of multiple conflicting versions, you *will* eventually encounter insidious issues that hard to debug and potentially a security hazard, see for example https://github.com/revealjs/reveal/issues/1108
+      `reveal@${pc.bold(versions[0]!)} and reveal@${pc.bold(versions[1]!)} loaded but only one version should be loaded`,
+    );
+  }
+
+  if (globalObject.checkSingleInstance && globalObject.instances.length > 1) {
+    /*/ Not sure whether circular dependency can cause problems? In principle not since client-side code is ESM.
+    console.warn(clientNotSingleInstance)
+    /*/
+    assertWarning(false, clientNotSingleInstance, {
+      onlyOnce: true,
+      showStackTrace: true,
+    });
+    //*/
+  }
+}
+
+function onClientEntryServerRouting(isProduction: boolean) {
+  assertWarning(
+    globalObject.isClientRouting !== true,
+    clientRuntimesClonflict,
+    {
+      onlyOnce: true,
+      showStackTrace: true,
+    },
+  );
+  assertWarning(
+    globalObject.isClientRouting === undefined,
+    clientNotSingleInstance,
+    {
+      onlyOnce: true,
+      showStackTrace: true,
+    },
+  );
+  globalObject.isClientRouting = false;
+  if (isProduction) globalObject.checkSingleInstance = true;
+  assertSingleInstance();
+}
+function onClientEntryClientRouting(isProduction: boolean) {
+  assertWarning(
+    globalObject.isClientRouting !== false,
+    clientRuntimesClonflict,
+    {
+      onlyOnce: true,
+      showStackTrace: true,
+    },
+  );
+  assertWarning(
+    globalObject.isClientRouting === undefined,
+    clientNotSingleInstance,
+    {
+      onlyOnce: true,
+      showStackTrace: true,
+    },
+  );
+  globalObject.isClientRouting = true;
+  if (isProduction) globalObject.checkSingleInstance = true;
+  assertSingleInstance();
+}
+
+// Called by utils/assert.ts which is (most certainly) loaded by all entries. That way we don't have to call a callback for every entry. (There are a lot of entries: `client/router/`, `client/`, `node/runtime/`, `node/plugin/`, `node/cli`.)
+function onAssertModuleLoad() {
+  globalObject.instances.push(projectInfo.projectVersion);
+  assertSingleInstance();
+}
+
+function assertUsage(
+  condition: unknown,
+  errorMessage: string,
+): asserts condition {
+  if (condition) {
+    return;
+  }
+  const errMsg = `[reveal][Wrong Usage] ${errorMessage}`;
+  throw new Error(errMsg);
+}
+function assertWarning(
+  condition: unknown,
+  errorMessage: string,
+  {
+    onlyOnce,
+    showStackTrace,
+  }: { onlyOnce: boolean | string; showStackTrace: boolean },
+): void {
+  if (condition) {
+    return;
+  }
+  const msg = `[reveal][Warning] ${errorMessage}`;
+  if (onlyOnce) {
+    const { alreadyLogged } = globalObject;
+    const key = onlyOnce === true ? msg : onlyOnce;
+    if (alreadyLogged.has(key)) {
+      return;
+    } else {
+      alreadyLogged.add(key);
+    }
+  }
+  if (showStackTrace) {
+    console.warn(new Error(msg));
+  } else {
+    console.warn(msg);
+  }
+}

package/dist/core/gaurds/assertions/assertType.ts

@@ -0,0 +1,12 @@
+export { assertType };
+
+import { assert } from "./assert/index.js";
+
+/** Help TypeScript augment the type of objects. */
+function assertType<Thing, Clone>(
+  thing: Thing,
+  clone: Clone,
+): asserts thing is Thing & Clone {
+  // @ts-ignore
+  assert(thing === clone);
+}

package/dist/core/gaurds/assertions/assertUsage/base.ts

@@ -0,0 +1,43 @@
+import {numberOfStackTraceLinesToRemove} from "../../../globals/logger";
+import {addPrefixAssertType} from "../../../globals/tags/addPrefixAssertType";
+import {addPrefixProjectName} from "../../../globals/tags/addPrefixProjectName";
+import {addWhitespace} from "../../../utils/string/addWhitespace";
+import {createErrorWithCleanStackTrace} from "../../errors/createErrorWithCleanStackTrace";
+
+export { assertUsage };
+
+function assertUsage(
+  condition: unknown,
+  errMsg: string,
+  { showStackTrace }: { showStackTrace?: true } = {},
+): asserts condition {
+  if (condition) return;
+  // @ts-ignore
+  const globalObjectsAll = (globalThis[projectKey] =
+    // @ts-ignore
+    globalThis[projectKey] || {});
+  // @ts-ignore
+  const globalObject = (globalObjectsAll[key] =
+    // @ts-ignore
+    globalObjectsAll[key] || defaultValue);
+  showStackTrace = showStackTrace || globalObject.alwaysShowStackTrace;
+  errMsg = addWhitespace(errMsg);
+  errMsg = addPrefixAssertType(errMsg, "Wrong Usage");
+  errMsg = addPrefixProjectName(errMsg);
+  const usageError = createErrorWithCleanStackTrace(
+    errMsg,
+    numberOfStackTraceLinesToRemove,
+  );
+  if (showStackTrace) {
+    globalObject.showStackTraceList.add(usageError);
+  }
+  globalObject.onBeforeLog?.();
+  throw usageError;
+}
+
+//   if (showStackTrace) {
+//     globalObject.showStackTraceList.add(errMsg);
+//   }
+//   globalObject.onBeforeLog?.();
+//   throw errMsg;
+// }

package/dist/core/gaurds/assertions/assertUsage/index.ts

@@ -0,0 +1,3 @@
+export * from "./base.js";
+export * from "./log.js";
+export * from "./node.js";

package/dist/core/gaurds/assertions/assertUsage/log.ts

@@ -0,0 +1,29 @@
+import { numberOfStackTraceLinesToRemove } from "../../../globals/logger";
+import { globalObject } from "../../../globals/objects";
+import { addPrefixAssertType } from "../../../globals/tags/addPrefixAssertType";
+import { addPrefixProjectName } from "../../../globals/tags/addPrefixProjectName";
+import { addWhitespace } from "../../../utils/string/addWhitespace";
+import { createErrorWithCleanStackTrace } from "../../errors/createErrorWithCleanStackTrace";
+
+export { assertUsageLog };
+
+function assertUsageLog(
+  condition: unknown,
+  errMsg: string,
+  { showStackTrace }: { showStackTrace?: true } = {},
+): asserts condition {
+  if (condition) return;
+  showStackTrace = showStackTrace || globalObject.alwaysShowStackTrace;
+  errMsg = addWhitespace(errMsg);
+  errMsg = addPrefixAssertType(errMsg, "Wrong Usage");
+  errMsg = addPrefixProjectName(errMsg);
+  const usageError = createErrorWithCleanStackTrace(
+    errMsg,
+    numberOfStackTraceLinesToRemove,
+  );
+  if (showStackTrace) {
+    globalObject.showStackTraceList.add(usageError);
+  }
+  globalObject.onBeforeLog?.();
+  throw usageError;
+}

package/dist/core/gaurds/assertions/assertUsage/node.ts

@@ -0,0 +1,16 @@
+import { assertUsage } from "./base"
+
+export { assertUsageNode }
+
+function assertUsageNode() {
+  return assertUsage(
+    false,
+    [
+      "Following import is forbidden on the client-side:",
+      "  import { something } from 'vike/server'",
+      "Did you mean the following instead?",
+      "  import { something } from 'reveal/client/router'",
+    ].join("\n"),
+    { showStackTrace: true }
+  )
+}

package/dist/core/gaurds/assertions/assertV1Design.ts

@@ -0,0 +1,29 @@
+export { assertV1Design }
+
+import type { PageConfigBuildTime } from "../../../types/interfaces/page.js"
+
+import { PageFile } from "../../__internal/index.js"
+import { unique } from "../../utils/array/unique.js"
+import { isNotNullish } from "../validators/isNotNullish.js"
+import { assert } from "./assert/index.js"
+import { assertUsage } from "./assertUsage/index.js"
+import { assertWarning } from "./assertWarning/index.js"
+
+function assertV1Design(
+  pageConfigs: PageConfigBuildTime[] | boolean,
+  pageFilesAll: PageFile[] | boolean
+): void {
+  const isOldDesign =
+    pageFilesAll === true || (pageFilesAll !== false && pageFilesAll.length > 0)
+  if (isOldDesign) {
+    const indent = "- "
+    const filesOld = typeof pageFilesAll !== "boolean" && pageFilesAll.length > 0
+      ? pageFilesAll.map((p) => indent + p.filePath)
+      : []
+    const lines = [
+      "V0.4 design is no longer supported. Update to the V1 design, see https://reveal.dev/migration/v1-design for how to migrate.",
+      ...(filesOld.length > 0 ? ["Old design files:", ...filesOld] : [])
+    ]
+    assertUsage(false, lines.join("\n"))
+  }
+}

package/dist/core/gaurds/assertions/assertVersion/base.ts

@@ -0,0 +1,55 @@
+import { assert } from "../assert/base";
+import { assertUsage } from "../assertUsage";
+
+export { assertVersion };
+export { isVersionOrAbove };
+
+function assertVersion(
+  dependencyName: "Vite" | "Node.js",
+  versionActual: string,
+  versionExpected: `${number}.${number}.${number}`,
+) {
+  assertUsage(
+    isVersionOrAbove(versionActual, versionExpected),
+    `${dependencyName} ${versionActual} isn't supported, use ${dependencyName} >= ${versionExpected} instead.`,
+  );
+}
+
+function isVersionOrAbove(
+  versionActual: string,
+  versionExpected: `${number}.${number}.${number}`,
+): boolean {
+  const p1 = parseVersion(versionActual);
+  const p2 = parseVersion(versionExpected);
+
+  // major
+  if (p1[0] !== p2[0]) return p1[0] > p2[0];
+  // minor
+  if (p1[1] !== p2[1]) return p1[1] > p2[1];
+  // patch
+  if (p1[2] !== p2[2]) return p1[2] > p2[2];
+
+  // Same version
+  return true;
+}
+
+function parseVersion(version: string): [number, number, number] {
+  // Remove pre-release tag
+  version = version.split("-")[0]!;
+
+  let partsStr = version.split(".");
+
+  // Git seems to be using a fourth number: https://github.com/git/git/tree/master/Documentation/RelNotes
+  partsStr = partsStr.slice(0, 3);
+
+  // major.minor.patch
+  assert(partsStr.length === 3);
+  assert(partsStr.every((s) => s.length > 0));
+
+  const parts = partsStr.map((s) => parseInt(s, 10)) as [
+    number,
+    number,
+    number,
+  ];
+  return parts;
+}

package/dist/core/gaurds/assertions/assertVersion/index.ts

@@ -0,0 +1 @@
+export * from "./base.js";

package/dist/core/gaurds/assertions/assertWarning/base.ts

@@ -0,0 +1,43 @@
+import { numberOfStackTraceLinesToRemove } from "../../../globals/logger/numberOfStackTraceLinesToRemove";
+import { globalObject } from "../../../globals/objects/log";
+import { addPrefixAssertType } from "../../../globals/tags/addPrefixAssertType";
+import { addPrefixProjectName } from "../../../globals/tags/addPrefixProjectName";
+import { addWhitespace } from "../../../utils/string/addWhitespace";
+import { createErrorWithCleanStackTrace } from "../../errors/createErrorWithCleanStackTrace";
+
+export { assertWarning };
+
+function assertWarning(
+  condition: unknown,
+  msg: string,
+  {
+    onlyOnce,
+    showStackTrace,
+  }: { onlyOnce: boolean | string; showStackTrace?: true },
+): void {
+  if (condition) return;
+  showStackTrace = showStackTrace || globalObject.alwaysShowStackTrace;
+  msg = addWhitespace(msg);
+  msg = addPrefixAssertType(msg, "Warning");
+  msg = addPrefixProjectName(msg);
+  if (onlyOnce) {
+    const { alreadyLogged } = globalObject;
+    const key = onlyOnce === true ? msg : onlyOnce;
+    if (alreadyLogged.has(key)) {
+      return;
+    } else {
+      alreadyLogged.add(key);
+    }
+  }
+  globalObject.onBeforeLog?.();
+  if (showStackTrace) {
+    const err = createErrorWithCleanStackTrace(
+      msg,
+      numberOfStackTraceLinesToRemove,
+    );
+    globalObject.showStackTraceList.add(err);
+    globalObject.logger(err, "warn");
+  } else {
+    globalObject.logger(msg, "warn");
+  }
+}

package/dist/core/gaurds/assertions/assertWarning/index.ts

@@ -0,0 +1,2 @@
+export { assertWarningLog } from "./log.js";
+export { assertWarning } from "./base.js";

package/dist/core/gaurds/assertions/assertWarning/log.ts

@@ -0,0 +1,43 @@
+import { numberOfStackTraceLinesToRemove } from "../../../globals/logger/numberOfStackTraceLinesToRemove";
+import { globalObject } from "../../../globals/objects";
+import { addPrefixAssertType } from "../../../globals/tags/addPrefixAssertType";
+import { addPrefixProjectName } from "../../../globals/tags/addPrefixProjectName";
+import { addWhitespace } from "../../../utils/string/addWhitespace";
+import { createErrorWithCleanStackTrace } from "../../errors/createErrorWithCleanStackTrace";
+
+export { assertWarningLog };
+
+function assertWarningLog(
+  condition: unknown,
+  msg: string,
+  {
+    onlyOnce,
+    showStackTrace,
+  }: { onlyOnce: boolean | string; showStackTrace?: true },
+): void {
+  if (condition) return;
+  showStackTrace = showStackTrace || globalObject.alwaysShowStackTrace;
+  msg = addWhitespace(msg);
+  msg = addPrefixAssertType(msg, "Warning");
+  msg = addPrefixProjectName(msg);
+  if (onlyOnce) {
+    const { alreadyLogged } = globalObject;
+    const key = onlyOnce === true ? msg : onlyOnce;
+    if (alreadyLogged.has(key)) {
+      return;
+    } else {
+      alreadyLogged.add(key);
+    }
+  }
+  globalObject.onBeforeLog?.();
+  if (showStackTrace) {
+    const err = createErrorWithCleanStackTrace(
+      msg,
+      numberOfStackTraceLinesToRemove,
+    );
+    globalObject.showStackTraceList.add(err);
+    globalObject.logger(err, "warn");
+  } else {
+    globalObject.logger(msg, "warn");
+  }
+}

package/dist/core/gaurds/assertions/checkType.ts

@@ -0,0 +1,2 @@
+export function checkType<Type>(_: Type) {}
+export function castType<Cast, Type = {}>(_: Type): asserts _ is Type & Cast {}

package/dist/core/gaurds/debugger/createDebugger.ts

@@ -0,0 +1,196 @@
+export { createDebugger, isDebugActivated };
+export type { Debug };
+
+import pc from "@brillout/picocolors";
+import { getTerminalWidth } from "../../processing/getters/getTerminWidth.js";
+import { objectAssign } from "../../utils/object/objectAssign.js";
+import { checkType } from "../assertions/checkType.js";
+import { isArray } from "../validators/isArray.js";
+import { isBrowser } from "../validators/isBrowser.js";
+import { assert } from "../assertions/assert/index.js";
+import { isCallable } from "../validators/isCallable.js";
+import { assertUsage } from "../assertions/assertUsage/index.js";
+
+// Avoid this to be loaded in the browser. For isomorphic code: instead of `import { createDebugger } from './utils.js'`, use `globalThis.createDebugger()`.
+assert(!isBrowser());
+(globalThis as any).__jvstudio_debug_createDebugger = createDebugger;
+
+const flags = [
+  "reveal:error",
+  "reveal:extractAssets",
+  "reveal:extractExportNames",
+  "reveal:glob",
+  "reveal:log",
+  "reveal:optimizeDeps",
+  "reveal:outDir",
+  "reveal:pageFiles",
+  "reveal:pointer-imports",
+  "reveal:routing",
+  "reveal:setup",
+  "reveal:stream",
+  "reveal:virtual-files",
+] as const;
+const flagRegex = /\breveal:[a-zA-Z-]+/g;
+
+assertDEBUG();
+
+type Flag = (typeof flags)[number];
+type Debug = ReturnType<typeof createDebugger>;
+type Options = {
+  serialization?: {
+    emptyArray?: string;
+  };
+};
+
+function createDebugger(flag: Flag, optionsGlobal?: Options) {
+  checkType<`reveal:${string}`>(flag);
+  assert(flags.includes(flag));
+
+  const debugWithOptions = (optionsLocal: Options) => {
+    return (...msgs: unknown[]) => {
+      const options = { ...optionsGlobal, ...optionsLocal };
+      debug_(flag, options, ...msgs);
+    };
+  };
+  const debug = (...msgs: unknown[]) => debugWithOptions({})(...msgs);
+  objectAssign(debug, {
+    options: debugWithOptions,
+    isActivated: isDebugActivated(flag),
+  });
+  return debug;
+}
+
+function debug_(flag: Flag, options: Options, ...msgs: unknown[]) {
+  if (!isDebugActivated(flag)) return;
+  let [msgFirst, ...msgsRest] = msgs;
+  const padding = " ".repeat(flag.length + 1);
+  msgFirst = formatMsg(msgFirst, options, padding, "FIRST");
+  msgsRest = msgsRest.map((msg, i) => {
+    const position = i === msgsRest.length - 1 ? "LAST" : "MIDDLE";
+    return formatMsg(msg, options, padding, position);
+  });
+  let logFirst: unknown[];
+  let logsRest: unknown[];
+  const noNewLine =
+    msgsRest.length <= 1 &&
+    [msgFirst, ...msgsRest].every(
+      (m) => typeof m === "string" && !m.includes("\n"),
+    );
+  if (noNewLine) {
+    logFirst = [msgFirst, ...msgsRest].map((m) => String(m).trim());
+    logsRest = [];
+  } else {
+    logFirst = [msgFirst];
+    logsRest = msgsRest;
+  }
+  console.log("\x1b[1m%s\x1b[0m", flag, ...logFirst);
+  logsRest.forEach((msg) => {
+    console.log(msg);
+  });
+}
+
+function isDebugActivated(flag: Flag): boolean {
+  checkType<`reveal:${string}`>(flag);
+  assert(flags.includes(flag));
+  const DEBUG = getDEBUG();
+  const isActivated = DEBUG?.includes(flag) ?? false;
+  return isActivated;
+}
+
+function formatMsg(
+  info: unknown,
+  options: Options,
+  padding: string,
+  position?: "FIRST" | "MIDDLE" | "LAST",
+): string | undefined {
+  if (info === undefined) {
+    return undefined;
+  }
+
+  let str = position === "FIRST" ? "" : padding;
+
+  if (typeof info === "string") {
+    str += info;
+  } else if (isArray(info)) {
+    if (info.length === 0) {
+      str += options.serialization?.emptyArray ?? "[]";
+    } else {
+      str += info.map(strUnknown).join("\n");
+    }
+  } else {
+    str += strUnknown(info);
+  }
+
+  str = pad(str, padding);
+
+  if (position !== "LAST" && position !== "FIRST") {
+    str += "\n";
+  }
+
+  return str;
+}
+
+function pad(str: string, padding: string): string {
+  const terminalWidth = getTerminalWidth();
+  const lines: string[] = [];
+  str.split("\n").forEach((line) => {
+    if (!terminalWidth) {
+      lines.push(line);
+    } else {
+      chunk(line, terminalWidth - padding.length).forEach((chunk) => {
+        lines.push(chunk);
+      });
+    }
+  });
+  return lines.join("\n" + padding);
+}
+function chunk(str: string, size: number): string[] {
+  if (str.length <= size) {
+    return [str];
+  }
+  const chunks = str.match(new RegExp(".{1," + size + "}", "g"));
+  assert(chunks);
+  return chunks;
+}
+
+function strUnknown(thing: unknown) {
+  return typeof thing === "string" ? thing : strObj(thing);
+}
+function strObj(obj: unknown, newLines = true) {
+  return JSON.stringify(
+    obj,
+    replaceFunctionSerializer,
+    newLines ? 2 : undefined,
+  );
+}
+function replaceFunctionSerializer(
+  this: Record<string, unknown>,
+  _key: string,
+  value: unknown,
+) {
+  if (isCallable(value)) {
+    return value.toString().split(/\s+/).join(" ");
+  }
+  return value;
+}
+
+function assertDEBUG() {
+  const DEBUG = getDEBUG() ?? "";
+  const flagsActivated: string[] = DEBUG.match(flagRegex) ?? [];
+  flagsActivated.forEach((flag) => {
+    assertUsage(
+      (flags as readonly string[]).includes(flag),
+      `Unknown DEBUG flag ${pc.cyan(flag)}. Valid flags:\n${flags.map((f) => `  ${pc.cyan(f)}`).join("\n")}`,
+    );
+  });
+}
+
+function getDEBUG() {
+  let DEBUG: undefined | string;
+  // - `process` can be undefined in edge workers
+  // - We want bundlers to be able to statically replace `process.env.*`
+  try {
+    DEBUG = process.env.DEBUG;
+  } catch {}
+  return DEBUG;
+}