@alloy-js/core 0.19.0-dev.12 → 0.19.0-dev.3

package/src/components/UpdateFile.tsx

@@ -1,86 +0,0 @@
-import { computed } from "@vue/reactivity";
-import { join } from "pathe";
-import { useContext } from "../context.js";
-import { SourceDirectoryContext } from "../context/source-directory.js";
-import { createFileResource } from "../resource.js";
-import { Children } from "../runtime/component.js";
-import { SourceFile } from "./SourceFile.jsx";
-/**
- * Props for the UpdateFile component.
- */
-export interface UpdateFileProps {
-  /** The relative path to the file to update or create */
-  path: string;
-  /** Optional path to a file containing default content to use when the target file doesn't exist */
-  defaultContentPath?: string;
-  /** Optional default content to use when the target file doesn't exist */
-  defaultContent?: Children;
-  /** Function that receives the current file contents and returns the new content */
-  children: (currentContents: string | null) => Children;
-}
-
-/**
- * A component for updating existing files or initializing new files.
- *
- * This component allows you to read the current contents of a file and generate
- * new content based on those contents. If the file doesn't exist, it can use
- * default content from either a file path or inline content.
- *
- * @example
- * ```tsx
- * <UpdateFile path="config.json" defaultContent="{}">
- *   {(currentContents) => {
- *     const config = currentContents ? JSON.parse(currentContents) : {};
- *     config.newProperty = "value";
- *     return JSON.stringify(config, null, 2);
- *   }}
- * </UpdateFile>
- * ```
- */
-export function UpdateFile(props: UpdateFileProps) {
-  const parentDirectory = useContext(SourceDirectoryContext)!;
-  const fullPath = join(
-    parentDirectory ? parentDirectory.path : "",
-    props.path,
-  );
-  const fileResource = createFileResource(fullPath);
-
-  const newContent = computed(() => {
-    if (fileResource.loading) {
-      return;
-    }
-
-    if (fileResource.error) {
-      if ((fileResource.error as any).code === "ENOENT") {
-        if ("defaultContentPath" in props) {
-          const defaultContentResource = createFileResource(
-            props.defaultContentPath!,
-          );
-          return computed(() => {
-            if (defaultContentResource.loading) {
-              return;
-            }
-
-            if (defaultContentResource.error) {
-              throw defaultContentResource.error;
-            }
-
-            return props.children(defaultContentResource.data!);
-          });
-        } else {
-          return props.children(null);
-        }
-      }
-
-      throw fileResource.error;
-    }
-
-    return props.children(fileResource.data!);
-  });
-
-  return (
-    <SourceFile path={props.path} filetype="text/plain">
-      {newContent}
-    </SourceFile>
-  );
-}

package/src/host/alloy-host.browser.ts

@@ -1,56 +0,0 @@
-import { AlloyFileInterface, AlloyHostInterface } from "./interface.js";
-
-export const AlloyHost: AlloyHostInterface = {
-  read(source: string): AlloyFileInterface {
-    return new AlloyFile(source);
-  },
-
-  async write(
-    destination: string,
-    content: string | ArrayBuffer | Uint8Array | ReadableStream<Uint8Array>,
-  ): Promise<void> {
-    throw new Error(
-      "File system write operations are not supported in the browser",
-    );
-  },
-
-  async exists(source: string): Promise<boolean> {
-    throw new Error(
-      "File system exists operations are not supported in the browser",
-    );
-  },
-
-  async mkdir(path: string): Promise<void> {
-    throw new Error(
-      "File system mkdir operations are not supported in the browser",
-    );
-  },
-};
-
-export class AlloyFile implements AlloyFileInterface {
-  constructor(private source: string) {}
-
-  async text(): Promise<string> {
-    throw new Error(
-      "File system read operations are not supported in the browser",
-    );
-  }
-
-  async arrayBuffer(): Promise<ArrayBuffer> {
-    throw new Error(
-      "File system read operations are not supported in the browser",
-    );
-  }
-
-  async bytes(): Promise<Uint8Array> {
-    throw new Error(
-      "File system read operations are not supported in the browser",
-    );
-  }
-
-  stream(): ReadableStream<Uint8Array> {
-    throw new Error(
-      "File system read operations are not supported in the browser",
-    );
-  }
-}

package/src/host/alloy-host.ts

@@ -1,160 +0,0 @@
-import { createReadStream, createWriteStream } from "fs";
-import { access, mkdir, readFile, writeFile } from "fs/promises";
-import { AlloyFileInterface, AlloyHostInterface } from "./interface.js";
-
-export const AlloyHost: AlloyHostInterface = {
-  read(source: string): AlloyFileInterface {
-    return new AlloyFile(source);
-  },
-
-  async write(
-    destination: string,
-    content: string | ArrayBuffer | Uint8Array | ReadableStream<Uint8Array>,
-  ): Promise<void> {
-    if (typeof content === "string") {
-      //eslint-disable-next-line no-useless-catch
-      try {
-        await writeFile(destination, content, "utf8");
-      } catch (e) {
-        // get good callstacks
-        throw e;
-      }
-    } else if (content instanceof ArrayBuffer) {
-      //eslint-disable-next-line no-useless-catch
-      try {
-        await writeFile(destination, new Uint8Array(content));
-      } catch (e) {
-        // get good callstacks
-        throw e;
-      }
-    } else if (content instanceof Uint8Array) {
-      //eslint-disable-next-line no-useless-catch
-      try {
-        await writeFile(destination, content);
-      } catch (e) {
-        // get good callstacks
-        throw e;
-      }
-    } else {
-      // content is ReadableStream<Uint8Array>
-      //eslint-disable-next-line no-useless-catch
-      try {
-        const writeStream = createWriteStream(destination);
-        const reader = content.getReader();
-
-        try {
-          while (true) {
-            const { done, value } = await reader.read();
-            if (done) break;
-
-            await new Promise<void>((resolve, reject) => {
-              writeStream.write(value, (err) => {
-                if (err) reject(err);
-                else resolve();
-              });
-            });
-          }
-        } finally {
-          reader.releaseLock();
-          await new Promise<void>((resolve, reject) => {
-            writeStream.end((err?: Error) => {
-              if (err) reject(err);
-              else resolve();
-            });
-          });
-        }
-      } catch (e) {
-        // get good callstacks
-        throw e;
-      }
-    }
-  },
-
-  async exists(source: string): Promise<boolean> {
-    try {
-      await access(source);
-      return true;
-    } catch {
-      return false;
-    }
-  },
-
-  async mkdir(path: string): Promise<void> {
-    //eslint-disable-next-line no-useless-catch
-    try {
-      await mkdir(path, { recursive: true });
-    } catch (e) {
-      // get good callstacks
-      throw e;
-    }
-  },
-};
-
-export class AlloyFile implements AlloyFileInterface {
-  constructor(private source: string) {}
-
-  async text(): Promise<string> {
-    //eslint-disable-next-line no-useless-catch
-    try {
-      return await readFile(this.source, "utf8");
-    } catch (e) {
-      // get good callstacks
-      throw e;
-    }
-  }
-
-  async arrayBuffer(): Promise<ArrayBuffer> {
-    //eslint-disable-next-line no-useless-catch
-    try {
-      const buffer = await readFile(this.source);
-      return buffer.buffer.slice(
-        buffer.byteOffset,
-        buffer.byteOffset + buffer.byteLength,
-      );
-    } catch (e) {
-      // get good callstacks
-      throw e;
-    }
-  }
-
-  async bytes(): Promise<Uint8Array> {
-    //eslint-disable-next-line no-useless-catch
-    try {
-      const buffer = await readFile(this.source);
-      return new Uint8Array(buffer);
-    } catch (e) {
-      // get good callstacks
-      throw e;
-    }
-  }
-
-  stream(): ReadableStream<Uint8Array> {
-    //eslint-disable-next-line no-useless-catch
-    try {
-      const nodeStream = createReadStream(this.source);
-
-      return new ReadableStream<Uint8Array>({
-        start(controller) {
-          nodeStream.on("data", (chunk) => {
-            controller.enqueue(new Uint8Array(chunk as Buffer));
-          });
-
-          nodeStream.on("end", () => {
-            controller.close();
-          });
-
-          nodeStream.on("error", (err) => {
-            controller.error(err);
-          });
-        },
-
-        cancel() {
-          nodeStream.destroy();
-        },
-      });
-    } catch (e) {
-      // get good callstacks
-      throw e;
-    }
-  }
-}

package/src/host/interface.ts

@@ -1,153 +0,0 @@
-/**
- * Interface for the Alloy host file system operations.
- *
- * This interface abstracts file system operations to allow different
- * implementations across different environments (Node.js, browser, etc.).
- */
-export interface AlloyHostInterface {
-  /**
-   * Read a file from the file system.
-   *
-   * @param source - The path to the file to read
-   * @returns An AlloyFileInterface for accessing the file content in different formats
-   *
-   * @example
-   * ```typescript
-   * const file = AlloyHost.read('./config.json');
-   * const content = await file.text();
-   * ```
-   */
-  read(source: string): AlloyFileInterface;
-
-  /**
-   * Write content to a file in the file system.
-   *
-   * Supports writing different types of content including strings, binary data,
-   * and streams. For strings, content is written with UTF-8 encoding.
-   *
-   * @param destination - The path where the file should be written
-   * @param content - The content to write (string, ArrayBuffer, Uint8Array, or ReadableStream)
-   * @returns A Promise that resolves when the write operation is complete
-   *
-   * @example
-   * ```typescript
-   * // Write a string
-   * await AlloyHost.write('./output.txt', 'Hello, world!');
-   *
-   * // Write binary data
-   * const data = new Uint8Array([72, 101, 108, 108, 111]);
-   * await AlloyHost.write('./binary.dat', data);
-   * ```
-   */
-  write(
-    destination: string,
-    content: string | ArrayBuffer | Uint8Array | ReadableStream<Uint8Array>,
-  ): Promise<void>;
-
-  /**
-   * Check if a file or directory exists at the given path.
-   *
-   * @param source - The path to check for existence
-   * @returns A Promise that resolves to true if the path exists, false otherwise
-   *
-   * @example
-   * ```typescript
-   * const fileExists = await AlloyHost.exists('./config.json');
-   * if (fileExists) {
-   *   // File exists, safe to read
-   * }
-   * ```
-   */
-  exists(source: string): Promise<boolean>;
-
-  /**
-   * Create a directory at the specified path.
-   *
-   * Creates the directory and any necessary parent directories recursively.
-   * If the directory already exists, this operation succeeds without error.
-   *
-   * @param path - The path of the directory to create
-   * @returns A Promise that resolves when the directory creation is complete
-   *
-   * @example
-   * ```typescript
-   * await AlloyHost.mkdir('./output/nested/directory');
-   * ```
-   */
-  mkdir(path: string): Promise<void>;
-}
-
-/**
- * Interface for reading file content in different formats.
- *
- * This interface provides multiple ways to access the same file content,
- * allowing consumers to choose the most appropriate format for their use case.
- */
-export interface AlloyFileInterface {
-  /**
-   * Read the file content as a UTF-8 encoded string.
-   *
-   * @returns A Promise that resolves to the file content as a string
-   *
-   * @example
-   * ```typescript
-   * const file = AlloyHost.read('./config.json');
-   * const jsonString = await file.text();
-   * const config = JSON.parse(jsonString);
-   * ```
-   */
-  text(): Promise<string>;
-
-  /**
-   * Read the file content as an ArrayBuffer.
-   *
-   * Useful for working with binary data or when you need a raw buffer
-   * that can be used with various JavaScript APIs.
-   *
-   * @returns A Promise that resolves to the file content as an ArrayBuffer
-   *
-   * @example
-   * ```typescript
-   * const file = AlloyHost.read('./image.png');
-   * const buffer = await file.arrayBuffer();
-   * ```
-   */
-  arrayBuffer(): Promise<ArrayBuffer>;
-
-  /**
-   * Read the file content as a Uint8Array.
-   *
-   * Convenient for working with binary data when you need direct access
-   * to individual bytes.
-   *
-   * @returns A Promise that resolves to the file content as a Uint8Array
-   *
-   * @example
-   * ```typescript
-   * const file = AlloyHost.read('./binary.dat');
-   * const bytes = await file.bytes();
-   * console.log('First byte:', bytes[0]);
-   * ```
-   */
-  bytes(): Promise<Uint8Array>;
-
-  /**
-   * Get a readable stream of the file content.
-   *
-   * Useful for processing large files without loading the entire content
-   * into memory at once, or for piping data to other streams.
-   *
-   * @returns A ReadableStream that yields Uint8Array chunks of the file content
-   *
-   * @example
-   * ```typescript
-   * const file = AlloyHost.read('./large-file.dat');
-   * const stream = file.stream();
-   *
-   * for await (const chunk of stream) {
-   *   console.log('Received chunk:', chunk);
-   * }
-   * ```
-   */
-  stream(): ReadableStream<Uint8Array>;
-}

package/src/resource.ts

@@ -1,152 +0,0 @@
-import { isRef, reactive, Ref } from "@vue/reactivity";
-import { AlloyHost } from "./host/alloy-host.js";
-import { effect } from "./reactivity.js";
-import { trackPromise } from "./scheduler.js";
-
-/**
- * Represents an external resource fetched asynchronously.
- */
-export interface Resource<T> {
-  /**
-   * The data if it's been loaded successfully. Null when not yet loaded or
-   * there was an error.
-   */
-  data: T | null;
-
-  /**
-   * Whether the resource is still being fetched.
-   */
-  loading: boolean;
-
-  /**
-   * The error loading the resource, if any.
-   */
-  error: null | Error;
-}
-
-/**
- * Create a resource that fetches data asynchronously.
- *
- * This function has two overloads:
- * 1. Simple fetcher - fetches data once when the resource is created
- * 2. Reactive fetcher - fetches data when a reactive source changes
- *
- * @example
- * ```typescript
- * // Simple usage - fetches data once when created
- * const userResource = createResource(async () => {
- *   const response = await fetch('/api/user');
- *   return response.json();
- * });
- *
- * // Access the resource state
- * console.log(userResource.loading); // true initially
- * console.log(userResource.data);    // null initially
- * console.log(userResource.error);   // null initially
- * ```
- *
- * @example
- * ```typescript
- * // Reactive usage - fetches data when the ref changes
- * const userId = ref(1);
- *
- * const userResource = createResource(userId, async (id) => {
- *   const response = await fetch(`/api/user/${id}`);
- *   return response.json();
- * });
- *
- * // The fetcher will be called automatically when userId changes
- * userId.value = 2; // This triggers a new fetch with id=2
- * ```
- */
-export function createResource<U>(fetcher: () => Promise<U>): Resource<U>;
-/**
- * Create a resource that fetches data asynchronously based on a reactive source.
- */
-export function createResource<T, U>(
-  refSource: Ref<T> | (() => T),
-  fetcher: (input: T) => Promise<U>,
-): Resource<U>;
-export function createResource<T, U>(
-  fetcherOrSource: (() => Promise<U>) | Ref<T> | (() => T),
-  maybeFetcher?: (input: T) => Promise<U>,
-): Resource<U> {
-  let getter: Ref<T> | (() => T) | null = null;
-  let fetcher: (() => Promise<U>) | ((input: T) => Promise<U>);
-
-  if (arguments.length === 1) {
-    fetcher = fetcherOrSource as () => Promise<U>;
-  } else {
-    getter = fetcherOrSource as Ref<T> | (() => T);
-    fetcher = maybeFetcher!;
-  }
-
-  const resource: Resource<U> = reactive({
-    data: null,
-    loading: true,
-    error: null,
-  });
-
-  if (!getter) {
-    const promise = (fetcher as () => Promise<U>)();
-    trackPromise(
-      promise
-        .then((result) => {
-          resource.data = result;
-          resource.loading = false;
-        })
-        .catch((error) => {
-          resource.error = error;
-          resource.loading = false;
-        }),
-    );
-  } else {
-    effect(() => {
-      let input: T;
-      if (isRef(getter)) {
-        input = getter.value;
-      } else {
-        input = getter();
-      }
-      const promise = (fetcher as (input: T) => Promise<U>)(input);
-      trackPromise(promise);
-      promise.then(
-        (result) => {
-          resource.data = result;
-          resource.loading = false;
-        },
-        (error) => {
-          resource.error = error;
-          resource.loading = false;
-        },
-      );
-    });
-  }
-
-  return resource;
-}
-
-/**
- * Create a resource that reads a file from the file system.
- *
- * This is a convenience function that creates a resource for reading file content
- * using the AlloyHost file system API. The file is read as text when the resource
- * is created.
- *
- * @example
- * ```typescript
- * // Read a configuration file
- * const configResource = createFileResource('./config.json');
- *
- * // Access the file content
- * if (!configResource.loading && !configResource.error) {
- *   const configText = configResource.data; // string content of the file
- *   const config = JSON.parse(configText);
- * }
- * ```
- */
-export function createFileResource(path: string) {
-  return createResource(() => {
-    return AlloyHost.read(path).text();
-  });
-}