@revealui/core 0.0.1-pre.1 → 0.0.1-pre.2

package/dist/core/types/generator.ts

@@ -1,316 +0,0 @@
-/**
- * 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

@@ -1,10 +0,0 @@
-// 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

@@ -1,52 +0,0 @@
-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

@@ -1,130 +0,0 @@
-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

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

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

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

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

@@ -1,8 +0,0 @@
-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

@@ -1,157 +0,0 @@
-/* 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

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

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

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