@revealui/core 0.0.1-pre.0

package/dist/core/types/generator.ts

@@ -0,0 +1,316 @@
+/**
+ * Type generator for RevealUI
+ * Auto-generates types from Vike routes and PayloadCMS collections
+ */
+
+import fs from "node:fs/promises";
+import path from "node:path";
+import pkg from "fast-glob";
+const { glob } = pkg;
+import type { ResolvedConfig } from "vite";
+
+export interface RouteInfo {
+  pageId: string;
+  routeString: string;
+  routeParams: string[];
+  filePath: string;
+}
+
+export interface CollectionInfo {
+  name: string;
+  slug: string;
+  fields: Array<{
+    name: string;
+    type: string;
+    required: boolean;
+  }>;
+}
+
+export interface GeneratedTypes {
+  routes: RouteInfo[];
+  collections: CollectionInfo[];
+}
+
+/**
+ * Scans for page files and extracts route information
+ */
+export async function scanRoutes(
+  rootDir: string = process.cwd()
+): Promise<RouteInfo[]> {
+  const routes: RouteInfo[] = [];
+  const pagesDir = path.join(rootDir, "src", "pages");
+
+  try {
+    // Find all page files
+    const pageFiles = await glob("**/*.page.{tsx,ts,jsx,js}", {
+      cwd: pagesDir,
+      absolute: true,
+    });
+
+    for (const filePath of pageFiles) {
+      const relativePath = path.relative(pagesDir, filePath);
+      const pageId = relativePath.replace(/\.page\.(tsx|ts|jsx|js)$/, "");
+
+      // Extract route string from file path
+      // e.g., /pages/users/[id]/+Page.tsx -> /users/:id
+      let routeString = pageId
+        .replace(/\/\+Page$/, "")
+        .replace(/\[([^\]]+)\]/g, ":$1")
+        .replace(/^index$/, "/")
+        .replace(/^\//, "");
+
+      if (!routeString.startsWith("/")) {
+        routeString = "/" + routeString;
+      }
+
+      // Extract route parameters
+      const routeParams: string[] = [];
+      const paramMatches = routeString.matchAll(/:(\w+)/g);
+      for (const match of paramMatches) {
+        if (match[1]) {
+          routeParams.push(match[1]);
+        }
+      }
+
+      routes.push({
+        pageId,
+        routeString,
+        routeParams,
+        filePath: relativePath,
+      });
+    }
+  } catch (error) {
+    // Pages directory might not exist
+    if ((error as { code?: string }).code !== "ENOENT") {
+      throw error;
+    }
+  }
+
+  return routes;
+}
+
+/**
+ * Scans for PayloadCMS collections and extracts type information
+ */
+export async function scanPayloadCollections(
+  rootDir: string = process.cwd()
+): Promise<CollectionInfo[]> {
+  const collections: CollectionInfo[] = [];
+  const collectionsDir = path.join(rootDir, "src", "lib", "collections");
+
+  try {
+    // Find all collection files
+    const collectionFiles = await glob("**/index.{ts,tsx}", {
+      cwd: collectionsDir,
+      absolute: true,
+    });
+
+    for (const filePath of collectionFiles) {
+      try {
+        const content = await fs.readFile(filePath, "utf-8");
+
+        // Extract collection name from file
+        const dirName = path.dirname(filePath);
+        const collectionName = path.basename(dirName);
+
+        // Try to extract slug from content
+        const slugMatch = content.match(/slug:\s*['"]([^'"]+)['"]/);
+        const slug = slugMatch ? slugMatch[1] : collectionName.toLowerCase();
+
+        // Extract fields (simplified - in production, would parse AST)
+        const fields: Array<{ name: string; type: string; required: boolean }> =
+          [];
+        const fieldMatches = content.matchAll(
+          /{\s*name:\s*['"]([^'"]+)['"][^}]*type:\s*['"]([^'"]+)['"][^}]*required:\s*(true|false)/g
+        );
+
+        for (const match of fieldMatches) {
+          if (match[1] && match[2]) {
+            fields.push({
+              name: match[1],
+              type: match[2],
+              required: match[3] === "true",
+            });
+          }
+        }
+
+        collections.push({
+          name: collectionName,
+          slug: slug || collectionName.toLowerCase(),
+          fields,
+        });
+      } catch (error) {
+        // Skip files that can't be parsed
+        console.warn(`Failed to parse collection file: ${filePath}`, error);
+      }
+    }
+  } catch (error) {
+    // Collections directory might not exist
+    if ((error as { code?: string }).code !== "ENOENT") {
+      throw error;
+    }
+  }
+
+  return collections;
+}
+
+/**
+ * Generates TypeScript type definitions from routes and collections
+ */
+export function generateTypeDefinitions(
+  routes: RouteInfo[],
+  collections: CollectionInfo[]
+): string {
+  const lines: string[] = [];
+
+  lines.push("// Auto-generated types from RevealUI");
+  lines.push("// Do not edit this file manually");
+  lines.push("");
+  lines.push("// Route types");
+  lines.push("export type RouteParams = {");
+
+  for (const route of routes) {
+    if (route.routeParams.length > 0) {
+      const paramsType = route.routeParams
+        .map((param) => `    ${param}: string`)
+        .join(";\n");
+      lines.push(`  "${route.routeString}": {`);
+      lines.push(paramsType);
+      lines.push("  };");
+    }
+  }
+
+  lines.push("};");
+  lines.push("");
+
+  lines.push("// PayloadCMS Collection types");
+  for (const collection of collections) {
+    const typeName = collection.name.charAt(0).toUpperCase() + collection.name.slice(1);
+    lines.push(`export interface ${typeName} {`);
+    for (const field of collection.fields) {
+      const optional = field.required ? "" : "?";
+      const tsType = mapPayloadTypeToTS(field.type);
+      lines.push(`  ${field.name}${optional}: ${tsType};`);
+    }
+    lines.push("}");
+    lines.push("");
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * Maps PayloadCMS field types to TypeScript types
+ */
+function mapPayloadTypeToTS(payloadType: string): string {
+  const typeMap: Record<string, string> = {
+    text: "string",
+    textarea: "string",
+    email: "string",
+    password: "string",
+    number: "number",
+    date: "Date | string",
+    select: "string",
+    checkbox: "boolean",
+    relationship: "string | { id: string }",
+    upload: "string | { id: string }",
+    array: "unknown[]",
+    group: "Record<string, unknown>",
+    blocks: "unknown[]",
+  };
+
+  return typeMap[payloadType.toLowerCase()] || "unknown";
+}
+
+/**
+ * Generates types and writes them to .reveal/types directory
+ */
+export async function generateTypes(
+  outputDir: string = path.join(process.cwd(), ".reveal", "types")
+): Promise<void> {
+  // Create output directory
+  await fs.mkdir(outputDir, { recursive: true });
+
+  // Scan for routes and collections
+  const routes = await scanRoutes();
+  const collections = await scanPayloadCollections();
+
+  // Generate type definitions
+  const typeDefinitions = generateTypeDefinitions(routes, collections);
+
+  // Write to file
+  const outputFile = path.join(outputDir, "generated.ts");
+  await fs.writeFile(outputFile, typeDefinitions, "utf-8");
+
+  // Also generate index file for easy imports
+  const indexContent = `export * from "./generated.js";\n`;
+  await fs.writeFile(path.join(outputDir, "index.ts"), indexContent, "utf-8");
+
+  console.log(`✓ Generated types for ${routes.length} routes and ${collections.length} collections`);
+  console.log(`✓ Types written to ${outputFile}`);
+}
+
+/**
+ * Watches for changes and regenerates types
+ * 
+ * @param outputDir - Directory to write generated types (default: .reveal/types)
+ * @param callback - Optional callback to call after regeneration
+ * @param watchInterval - Polling interval in milliseconds (default: 2000)
+ * @returns Promise that resolves when watch is set up
+ * 
+ * @example
+ * ```ts
+ * // Watch for changes and regenerate types
+ * await watchTypes()
+ * 
+ * // With custom output directory and callback
+ * await watchTypes('./types', () => {
+ *   console.log('Types regenerated!')
+ * })
+ * ```
+ */
+export async function watchTypes(
+  outputDir: string = path.join(process.cwd(), ".reveal", "types"),
+  callback?: () => void,
+  watchInterval: number = 2000
+): Promise<() => void> {
+  let lastRoutes: RouteInfo[] = [];
+  let lastCollections: CollectionInfo[] = [];
+  let isWatching = true;
+
+  const checkForChanges = async () => {
+    if (!isWatching) return;
+
+    try {
+      const routes = await scanRoutes();
+      const collections = await scanPayloadCollections();
+
+      const routesChanged =
+        JSON.stringify(routes) !== JSON.stringify(lastRoutes);
+      const collectionsChanged =
+        JSON.stringify(collections) !== JSON.stringify(lastCollections);
+
+      if (routesChanged || collectionsChanged) {
+        await generateTypes(outputDir);
+        lastRoutes = routes;
+        lastCollections = collections;
+        if (callback) callback();
+      }
+    } catch (error) {
+      console.error("Error watching for type changes:", error);
+    }
+  };
+
+  // Initial generation
+  await checkForChanges();
+
+  // Watch for changes
+  const intervalId = setInterval(checkForChanges, watchInterval);
+
+  // Return stop function
+  return () => {
+    isWatching = false;
+    clearInterval(intervalId);
+  };
+}
+

package/dist/core/utils/array/includes.ts

@@ -0,0 +1,10 @@
+// https://stackoverflow.com/questions/56565528/typescript-const-assertions-how-to-use-array-prototype-includes/74213179#74213179
+/** Same as Array.prototype.includes() but with type inference */
+export function includes<T>(values: readonly T[], x: unknown): x is T {
+  return values.includes(x as any);
+}
+/*
+export function includes<Arr extends any[] | readonly any[]>(arr: Arr, el: unknown): el is Arr[number] {
+  return arr.includes(el as any)
+}
+*/

package/dist/core/utils/array/slice.ts

@@ -0,0 +1,52 @@
+import { assert } from "../../gaurds/assertions/assert/base";
+
+export { slice };
+
+function slice<Element, T extends Array<Element>>(
+  thing: T,
+  from: number,
+  to: number,
+): T;
+function slice(thing: string, from: number, to: number): string;
+function slice(
+  thing: string | unknown[],
+  from: number,
+  to: number,
+): string | unknown[] {
+  if (typeof thing === "string") {
+    return sliceArray(thing.split(""), from, to).join("");
+  } else {
+    return sliceArray(thing, from, to);
+  }
+}
+
+function sliceArray<Element, T extends Array<Element>>(
+  list: T,
+  from: number,
+  to: number,
+): T {
+  const listSlice: T = [] as unknown as T;
+
+  let start = from >= 0 ? from : list.length + from;
+  assert(start >= 0 && start <= list.length);
+  let end = to >= 0 ? to : list.length + to;
+  assert(end >= 0 && end <= list.length);
+
+  while (true) {
+    if (start === end) {
+      break;
+    }
+    if (start === list.length) {
+      start = 0;
+    }
+    if (start === end) {
+      break;
+    }
+    const el = list[start];
+    assert(el !== undefined);
+    listSlice.push(el);
+    start++;
+  }
+
+  return listSlice;
+}

package/dist/core/utils/array/sorter.ts

@@ -0,0 +1,130 @@
+import { assert } from "../../gaurds/assertions/assert/base";
+
+export { higherFirst };
+export { lowerFirst };
+export { makeFirst };
+export { makeLast };
+export { reverse };
+
+// -1 => element1 first (i.e. `indexOf(element1) < indexOf(element2)`)
+// +1 => element2 first (i.e. `indexOf(element2) < indexOf(element1)`)
+// 0 => keep original order of element1 and element2
+
+/**
+ * ```js
+ * let arr = [
+ *   { price: 10 },
+ *   { price: 1000 },
+ *   { price: 100 }
+ * ]
+ * arr = arr.sort(higherFirst(el => el.price))
+ * isEqual(arr, [
+ *   { price: 1000 },
+ *   { price: 100 },
+ *   { price: 10 }
+ * ])
+ * ```
+ */
+function higherFirst<T>(
+  getValue: (element: T) => number,
+): (element1: T, element2: T) => 0 | 1 | -1 {
+  return (element1: T, element2: T) => {
+    const val1 = getValue(element1);
+    const val2 = getValue(element2);
+    if (val1 === val2) {
+      return 0;
+    }
+    return val1 > val2 ? -1 : 1;
+  };
+}
+
+/**
+ * ```js
+ * let arr = [
+ *   { price: 10 },
+ *   { price: 1000 },
+ *   { price: 100 }
+ * ]
+ * arr = arr.sort(lowerFirst(el => el.price))
+ * isEqual(arr, [
+ *   { price: 10 },
+ *   { price: 100 },
+ *   { price: 1000 }
+ * ])
+ * ```
+ */
+function lowerFirst<T>(
+  getValue: (element: T) => number,
+): (element1: T, element2: T) => 0 | 1 | -1 {
+  return (element1: T, element2: T) => {
+    const val1 = getValue(element1);
+    const val2 = getValue(element2);
+    if (val1 === val2) {
+      return 0;
+    }
+    return val1 < val2 ? -1 : 1;
+  };
+}
+
+/**
+ * ```js
+ * let arr = [
+ *  { name: 'iphone', isRocket: false },
+ *  { name: 'starship', isRocket: true }
+ * ]
+ * arr = arr.sort(makeFirst(el => el.isRocket))
+ * isEqual(arr, [
+ *  { name: 'starship', isRocket: true },
+ *  { name: 'iphone', isRocket: false }
+ * ])
+ * ```
+ */
+function makeFirst<T>(
+  getValue: (element: T) => boolean | null,
+): (element1: T, element2: T) => 0 | 1 | -1 {
+  return (element1: T, element2: T) => {
+    const val1 = getValue(element1);
+    const val2 = getValue(element2);
+    assert([true, false, null].includes(val1));
+    assert([true, false, null].includes(val2));
+    if (val1 === val2) {
+      return 0;
+    }
+    if (val1 === true || val2 === false) {
+      return -1;
+    }
+    if (val2 === true || val1 === false) {
+      return 1;
+    }
+    return 0; // When both values are null
+  };
+}
+
+/**
+ * ```js
+ * let arr = [
+ *  { name: 'starship', isRocket: true },
+ *  { name: 'iphone', isRocket: false }
+ * ]
+ * arr = arr.sort(makeLast(el => el.isRocket))
+ * isEqual(arr, [
+ *  { name: 'iphone', isRocket: false },
+ *  { name: 'starship', isRocket: true }
+ * ])
+ * ```
+ */
+function makeLast<T>(getValue: (element: T) => boolean | null) {
+  return makeFirst((element: T) => {
+    const val = getValue(element);
+    if (val === null) {
+      return null;
+    } else {
+      return !val;
+    }
+  });
+}
+
+/** Reverse order result. */
+function reverse(sortKey: 0 | 1 | -1): 0 | 1 | -1 {
+  return (-1 * sortKey) as any;
+}

package/dist/core/utils/array/stringifyStringArray.ts

@@ -0,0 +1,7 @@
+export { stringifyStringArray };
+
+function stringifyStringArray(stringList: string[] | readonly string[]) {
+  return (
+    "[" + stringList.map((str: string) => "'" + str + "'").join(", ") + "]"
+  );
+}

package/dist/core/utils/array/unique.ts

@@ -0,0 +1,5 @@
+export { unique };
+
+function unique<T>(arr: T[]): T[] {
+  return Array.from(new Set(arr));
+}

package/dist/core/utils/async/genPromise.ts

@@ -0,0 +1,8 @@
+export function genPromise<T = void>(): {
+  promise: Promise<T>;
+  resolve: (val: T) => void;
+} {
+  let resolve!: (val: T) => void;
+  const promise = new Promise<T>((r) => (resolve = r));
+  return { promise, resolve };
+}

package/dist/core/utils/async/pLimit.ts

@@ -0,0 +1,157 @@
+/* Copied from https://github.com/sindresorhus/p-limit */
+
+export { pLimit };
+export type PLimit = (
+  job: () => Promise<void>,
+) => Promise<undefined> & { __stamp?: Symbol };
+
+function pLimit(concurrency: number): PLimit {
+  if (
+    !(
+      (Number.isInteger(concurrency) ||
+        concurrency === Number.POSITIVE_INFINITY) &&
+      concurrency > 0
+    )
+  ) {
+    throw new TypeError("Expected concurrency to be a number from 1 and up");
+  }
+
+  const queue = new Queue();
+  let activeCount = 0;
+
+  const next = () => {
+    activeCount--;
+
+    if (queue.size > 0) {
+      queue.dequeue()();
+    }
+  };
+
+  // @ts-ignore
+  const run = async (fn, resolve, args) => {
+    activeCount++;
+
+    const result = (async () => fn(...args))();
+
+    resolve(result);
+
+    try {
+      await result;
+    } catch {}
+
+    next();
+  };
+
+  // @ts-ignore
+  const enqueue = (fn, resolve, args) => {
+    queue.enqueue(run.bind(undefined, fn, resolve, args));
+    (async () => {
+      // This function needs to wait until the next microtask before comparing
+      // `activeCount` to `concurrency`, because `activeCount` is updated asynchronously
+      // when the run function is dequeued and called. The comparison in the if-statement
+      // needs to happen asynchronously as well to get an up-to-date value for `activeCount`.
+      await Promise.resolve();
+
+      if (activeCount < concurrency && queue.size > 0) {
+        queue.dequeue()();
+      }
+    })();
+  };
+
+  // @ts-ignore
+  const generator = (fn, ...args) =>
+    new Promise((resolve) => {
+      enqueue(fn, resolve, args);
+    });
+
+  Object.defineProperties(generator, {
+    activeCount: {
+      get: () => activeCount,
+    },
+    pendingCount: {
+      get: () => queue.size,
+    },
+    clearQueue: {
+      value: () => {
+        queue.clear();
+      },
+    },
+  });
+
+  // @ts-ignore
+  return generator;
+}
+
+/*
+How it works:
+`this.#head` is an instance of `Node` which keeps track of its current value and nests another instance of `Node` that keeps the value that comes after it. When a value is provided to `.enqueue()`, the code needs to iterate through `this.#head`, going deeper and deeper to find the last value. However, iterating through every single item is slow. This problem is solved by saving a reference to the last value as `this.#tail` so that it can reference it to add a new value.
+*/
+
+class Node {
+  value;
+  // @ts-ignore
+  next;
+
+  // @ts-ignore
+  constructor(value) {
+    this.value = value;
+  }
+}
+
+export default class Queue {
+  // @ts-ignore
+  #head;
+  // @ts-ignore
+  #tail;
+  // @ts-ignore
+  #size;
+
+  constructor() {
+    this.clear();
+  }
+
+  // @ts-ignore
+  enqueue(value) {
+    const node = new Node(value);
+
+    if (this.#head) {
+      this.#tail.next = node;
+      this.#tail = node;
+    } else {
+      this.#head = node;
+      this.#tail = node;
+    }
+
+    this.#size++;
+  }
+
+  dequeue() {
+    const current = this.#head;
+    if (!current) {
+      return;
+    }
+
+    this.#head = this.#head.next;
+    this.#size--;
+    return current.value;
+  }
+
+  clear() {
+    this.#head = undefined;
+    this.#tail = undefined;
+    this.#size = 0;
+  }
+
+  get size() {
+    return this.#size;
+  }
+
+  *[Symbol.iterator]() {
+    let current = this.#head;
+
+    while (current) {
+      yield current.value;
+      current = current.next;
+    }
+  }
+}

package/dist/core/utils/async/sleep.ts

@@ -0,0 +1,3 @@
+export function sleep(milliseconds: number): Promise<void> {
+  return new Promise((r) => setTimeout(r, milliseconds));
+}

package/dist/core/utils/async/throttle.ts

@@ -0,0 +1,14 @@
+export { throttle };
+
+function throttle(func: Function, waitTime: number) {
+  let isQueued: boolean = false;
+  return () => {
+    if (!isQueued) {
+      isQueued = true;
+      setTimeout(() => {
+        isQueued = false;
+        func();
+      }, waitTime);
+    }
+  };
+}