@larkiny/astro-github-loader 0.11.3 → 0.12.0

package/dist/github.logger.d.ts

@@ -1,7 +1,7 @@
 /**
  * Multi-level logging system for astro-github-loader
  */
-export type LogLevel = 'silent' | 'default' | 'verbose' | 'debug';
+export type LogLevel = "silent" | "default" | "verbose" | "debug";
 export interface LoggerOptions {
     level: LogLevel;
     prefix?: string;
@@ -16,7 +16,7 @@ export interface ImportSummary {
     assetsDownloaded?: number;
     assetsCached?: number;
     duration: number;
-    status: 'success' | 'error' | 'cancelled';
+    status: "success" | "error" | "cancelled";
     error?: string;
 }
 export interface SyncSummary {

package/dist/github.logger.js

@@ -6,10 +6,10 @@
  */
 export class Logger {
     constructor(options) {
-        this.spinnerChars = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+        this.spinnerChars = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
         this.spinnerIndex = 0;
         this.level = options.level;
-        this.prefix = options.prefix || '';
+        this.prefix = options.prefix || "";
     }
     /**
      * Set the logging level
@@ -51,7 +51,7 @@ export class Logger {
      * Default level - summary information only
      */
     info(message) {
-        if (this.shouldLog('default')) {
+        if (this.shouldLog("default")) {
             console.log(this.formatMessage(message));
         }
     }
@@ -59,7 +59,7 @@ export class Logger {
      * Verbose level - detailed operation information
      */
     verbose(message) {
-        if (this.shouldLog('verbose')) {
+        if (this.shouldLog("verbose")) {
             console.log(this.formatMessage(message));
         }
     }
@@ -67,7 +67,7 @@ export class Logger {
      * Debug level - all information including diagnostics
      */
     debug(message) {
-        if (this.shouldLog('debug')) {
+        if (this.shouldLog("debug")) {
             console.log(this.formatMessage(message));
         }
     }
@@ -75,7 +75,7 @@ export class Logger {
      * Error - always shown unless silent
      */
     error(message) {
-        if (this.shouldLog('default')) {
+        if (this.shouldLog("default")) {
             console.error(this.formatMessage(message));
         }
     }
@@ -83,7 +83,7 @@ export class Logger {
      * Warning - shown at default level and above
      */
     warn(message) {
-        if (this.shouldLog('default')) {
+        if (this.shouldLog("default")) {
             console.warn(this.formatMessage(message));
         }
     }
@@ -91,27 +91,32 @@ export class Logger {
      * Log structured import summary (default level)
      */
     logImportSummary(summary) {
-        if (!this.shouldLog('default'))
+        if (!this.shouldLog("default"))
             return;
-        const statusIcon = summary.status === 'success' ? '✅' : summary.status === 'error' ? '❌' : '🚫';
-        this.info('');
+        const statusIcon = summary.status === "success"
+            ? "✅"
+            : summary.status === "error"
+                ? "❌"
+                : "🚫";
+        this.info("");
         this.info(`📊 Import Summary: ${summary.configName}`);
-        this.info(`├─ Repository: ${summary.repository}${summary.ref ? `@${summary.ref}` : ''}`);
+        this.info(`├─ Repository: ${summary.repository}${summary.ref ? `@${summary.ref}` : ""}`);
         this.info(`├─ Files: ${summary.filesProcessed} processed, ${summary.filesUpdated} updated, ${summary.filesUnchanged} unchanged`);
-        if (summary.assetsDownloaded !== undefined || summary.assetsCached !== undefined) {
+        if (summary.assetsDownloaded !== undefined ||
+            summary.assetsCached !== undefined) {
             const downloaded = summary.assetsDownloaded || 0;
             const cached = summary.assetsCached || 0;
             this.info(`├─ Assets: ${downloaded} downloaded, ${cached} cached`);
         }
         this.info(`├─ Duration: ${(summary.duration / 1000).toFixed(1)}s`);
-        this.info(`└─ Status: ${statusIcon} ${summary.status === 'success' ? 'Success' : summary.status === 'error' ? `Error: ${summary.error}` : 'Cancelled'}`);
-        this.info('');
+        this.info(`└─ Status: ${statusIcon} ${summary.status === "success" ? "Success" : summary.status === "error" ? `Error: ${summary.error}` : "Cancelled"}`);
+        this.info("");
     }
     /**
      * Log sync operation summary (default level)
      */
     logSyncSummary(configName, summary) {
-        if (!this.shouldLog('default'))
+        if (!this.shouldLog("default"))
             return;
         if (summary.added > 0 || summary.updated > 0 || summary.deleted > 0) {
             this.info(`Sync completed for ${configName}: ${summary.added} added, ${summary.updated} updated, ${summary.deleted} deleted (${summary.duration}ms)`);
@@ -124,7 +129,7 @@ export class Logger {
      * Log cleanup operation summary (default level)
      */
     logCleanupSummary(configName, summary) {
-        if (!this.shouldLog('default'))
+        if (!this.shouldLog("default"))
             return;
         if (summary.deleted > 0) {
             this.info(`Cleanup completed for ${configName}: ${summary.deleted} obsolete files deleted (${summary.duration}ms)`);
@@ -137,14 +142,18 @@ export class Logger {
      * Log file-level processing (verbose level)
      */
     logFileProcessing(action, filePath, details) {
-        const message = details ? `${action}: ${filePath} - ${details}` : `${action}: ${filePath}`;
+        const message = details
+            ? `${action}: ${filePath} - ${details}`
+            : `${action}: ${filePath}`;
         this.verbose(message);
     }
     /**
      * Log asset processing (verbose level)
      */
     logAssetProcessing(action, assetPath, details) {
-        const message = details ? `Asset ${action}: ${assetPath} - ${details}` : `Asset ${action}: ${assetPath}`;
+        const message = details
+            ? `Asset ${action}: ${assetPath} - ${details}`
+            : `Asset ${action}: ${assetPath}`;
         this.verbose(message);
     }
     /**
@@ -195,8 +204,8 @@ export class Logger {
     /**
      * Start a spinner with duration timer for long-running operations
      */
-    startSpinner(message = 'Processing...') {
-        if (this.level === 'silent')
+    startSpinner(message = "Processing...") {
+        if (this.level === "silent")
             return;
         this.spinnerStartTime = Date.now();
         this.spinnerIndex = 0;
@@ -232,7 +241,7 @@ export class Logger {
             process.stdout.write(`\r${formattedMessage}\n`);
         }
         else {
-            process.stdout.write('\r\x1b[K'); // Clear the line
+            process.stdout.write("\r\x1b[K"); // Clear the line
         }
         this.spinnerStartTime = undefined;
     }
@@ -243,11 +252,11 @@ export class Logger {
         this.startSpinner(message);
         try {
             const result = await fn();
-            this.stopSpinner(successMessage || `✅ ${message.replace(/^[🔄⏳]?\s*/, '')} completed`);
+            this.stopSpinner(successMessage || `✅ ${message.replace(/^[🔄⏳]?\s*/, "")} completed`);
             return result;
         }
         catch (error) {
-            this.stopSpinner(errorMessage || `❌ ${message.replace(/^[🔄⏳]?\s*/, '')} failed`);
+            this.stopSpinner(errorMessage || `❌ ${message.replace(/^[🔄⏳]?\s*/, "")} failed`);
             throw error;
         }
     }
@@ -255,6 +264,6 @@ export class Logger {
 /**
  * Create a logger instance with the specified level
  */
-export function createLogger(level = 'default', prefix) {
+export function createLogger(level = "default", prefix) {
     return new Logger({ level, prefix });
 }

package/dist/github.paths.d.ts

@@ -0,0 +1,76 @@
+import type { ExtendedLoaderContext, ImportOptions, MatchedPattern } from "./github.types.js";
+export interface ImportStats {
+    processed: number;
+    updated: number;
+    unchanged: number;
+    assetsDownloaded?: number;
+    assetsCached?: number;
+}
+/**
+ * Generates a unique identifier from a file path by removing the extension
+ * @param filePath - The file path to generate ID from
+ * @return {string} The generated identifier as a string with extension removed
+ * @internal
+ */
+export declare function generateId(filePath: string): string;
+/**
+ * Applies path mapping logic to get the final filename for a file
+ *
+ * Supports two types of path mappings:
+ * - **File mapping**: Exact file path match (e.g., 'docs/README.md' -> 'docs/overview.md')
+ * - **Folder mapping**: Folder path with trailing slash (e.g., 'docs/capabilities/' -> 'docs/')
+ *
+ * @param filePath - Original source file path
+ * @param matchedPattern - The pattern that matched this file
+ * @param options - Import options containing path mappings
+ * @returns Final filename after applying path mapping logic
+ * @internal
+ */
+export declare function applyRename(filePath: string, matchedPattern?: MatchedPattern | null, options?: ImportOptions): string;
+/**
+ * Generates a local file path based on the matched pattern and file path
+ * @param filePath - The original file path from the repository
+ * @param matchedPattern - The pattern that matched this file (or null if no includes specified)
+ * @param options - Import options containing includes patterns for path mapping lookups
+ * @return {string} The local file path where this content should be stored
+ * @internal
+ */
+export declare function generatePath(filePath: string, matchedPattern?: MatchedPattern | null, options?: ImportOptions): string;
+/**
+ * Checks if a file path should be included and returns the matching pattern
+ * @param filePath - The file path to check (relative to the repository root)
+ * @param options - Import options containing includes patterns
+ * @returns Object with include status and matched pattern, or null if not included
+ * @internal
+ */
+export declare function shouldIncludeFile(filePath: string, options: ImportOptions): {
+    included: true;
+    matchedPattern: MatchedPattern | null;
+} | {
+    included: false;
+    matchedPattern: null;
+};
+/**
+ * Get the headers needed to make a conditional request.
+ * Uses the etag and last-modified values from the meta store.
+ * @internal
+ */
+export declare function getHeaders({ init, meta, id, }: {
+    /** Initial headers to include */
+    init?: RequestInit["headers"];
+    /** Meta store to get etag and last-modified values from */
+    meta: ExtendedLoaderContext["meta"];
+    id: string;
+}): Headers;
+/**
+ * Store the etag or last-modified headers from a response in the meta store.
+ * @internal
+ */
+export declare function syncHeaders({ headers, meta, id, }: {
+    /** Headers from the response */
+    headers: Headers;
+    /** Meta store to store etag and last-modified values in */
+    meta: ExtendedLoaderContext["meta"];
+    /** id string */
+    id: string;
+}): void;

package/dist/github.paths.js

@@ -0,0 +1,190 @@
+import path, { join, basename } from "node:path";
+import picomatch from "picomatch";
+/**
+ * Generates a unique identifier from a file path by removing the extension
+ * @param filePath - The file path to generate ID from
+ * @return {string} The generated identifier as a string with extension removed
+ * @internal
+ */
+export function generateId(filePath) {
+    let id = filePath;
+    // Remove file extension for ID generation
+    const lastDotIndex = id.lastIndexOf(".");
+    if (lastDotIndex > 0) {
+        id = id.substring(0, lastDotIndex);
+    }
+    return id;
+}
+/**
+ * Applies path mapping logic to get the final filename for a file
+ *
+ * Supports two types of path mappings:
+ * - **File mapping**: Exact file path match (e.g., 'docs/README.md' -> 'docs/overview.md')
+ * - **Folder mapping**: Folder path with trailing slash (e.g., 'docs/capabilities/' -> 'docs/')
+ *
+ * @param filePath - Original source file path
+ * @param matchedPattern - The pattern that matched this file
+ * @param options - Import options containing path mappings
+ * @returns Final filename after applying path mapping logic
+ * @internal
+ */
+export function applyRename(filePath, matchedPattern, options) {
+    if (options?.includes &&
+        matchedPattern &&
+        matchedPattern.index < options.includes.length) {
+        const includePattern = options.includes[matchedPattern.index];
+        if (includePattern.pathMappings) {
+            // First check for exact file match (current behavior - backwards compatible)
+            if (includePattern.pathMappings[filePath]) {
+                const mappingValue = includePattern.pathMappings[filePath];
+                return typeof mappingValue === "string"
+                    ? mappingValue
+                    : mappingValue.target;
+            }
+            // Then check for folder-to-folder mappings
+            for (const [sourceFolder, mappingValue] of Object.entries(includePattern.pathMappings)) {
+                // Check if this is a folder mapping (ends with /) and file is within it
+                if (sourceFolder.endsWith("/") && filePath.startsWith(sourceFolder)) {
+                    // Replace the source folder path with target folder path
+                    const targetFolder = typeof mappingValue === "string"
+                        ? mappingValue
+                        : mappingValue.target;
+                    const relativePath = filePath.slice(sourceFolder.length);
+                    return path.posix.join(targetFolder, relativePath);
+                }
+            }
+        }
+    }
+    // Return original filename if no path mapping found
+    return basename(filePath);
+}
+/**
+ * Generates a local file path based on the matched pattern and file path
+ * @param filePath - The original file path from the repository
+ * @param matchedPattern - The pattern that matched this file (or null if no includes specified)
+ * @param options - Import options containing includes patterns for path mapping lookups
+ * @return {string} The local file path where this content should be stored
+ * @internal
+ */
+export function generatePath(filePath, matchedPattern, options) {
+    if (matchedPattern) {
+        // Extract the directory part from the pattern (before any glob wildcards)
+        const pattern = matchedPattern.pattern;
+        const beforeGlob = pattern.split(/[*?{]/)[0];
+        // Remove the pattern prefix from the file path to get the relative path
+        let relativePath = filePath;
+        if (beforeGlob && filePath.startsWith(beforeGlob)) {
+            relativePath = filePath.substring(beforeGlob.length);
+            // Remove leading slash if present
+            if (relativePath.startsWith("/")) {
+                relativePath = relativePath.substring(1);
+            }
+        }
+        // If no relative path remains, use just the filename
+        if (!relativePath) {
+            relativePath = basename(filePath);
+        }
+        // Apply path mapping logic
+        const finalFilename = applyRename(filePath, matchedPattern, options);
+        // Always apply path mapping if applyRename returned something different from the original basename
+        // OR if there are pathMappings configured (since empty string mappings might return same basename)
+        const hasPathMappings = options?.includes?.[matchedPattern.index]?.pathMappings &&
+            Object.keys(options.includes[matchedPattern.index].pathMappings).length >
+                0;
+        if (finalFilename !== basename(filePath) || hasPathMappings) {
+            // Check if applyRename returned a full path (contains path separators) or just a filename
+            if (finalFilename.includes("/") || finalFilename.includes("\\")) {
+                // applyRename returned a full relative path - need to extract relative part
+                // Remove the pattern prefix to get the relative path within the pattern context
+                const beforeGlob = pattern.split(/[*?{]/)[0];
+                if (beforeGlob && finalFilename.startsWith(beforeGlob)) {
+                    relativePath = finalFilename.substring(beforeGlob.length);
+                    // Remove leading slash if present
+                    if (relativePath.startsWith("/")) {
+                        relativePath = relativePath.substring(1);
+                    }
+                }
+                else {
+                    relativePath = finalFilename;
+                }
+            }
+            else {
+                // applyRename returned just a filename
+                // If the filename is different due to pathMapping, use it directly
+                // This handles cases where pathMappings flatten directory structures
+                relativePath = finalFilename;
+            }
+        }
+        return join(matchedPattern.basePath, relativePath);
+    }
+    // Should not happen since we always use includes
+    throw new Error("No matched pattern provided - includes are required");
+}
+/**
+ * Checks if a file path should be included and returns the matching pattern
+ * @param filePath - The file path to check (relative to the repository root)
+ * @param options - Import options containing includes patterns
+ * @returns Object with include status and matched pattern, or null if not included
+ * @internal
+ */
+export function shouldIncludeFile(filePath, options) {
+    const { includes } = options;
+    // If no include patterns specified, include all files
+    if (!includes || includes.length === 0) {
+        return { included: true, matchedPattern: null };
+    }
+    // Check each include pattern to find a match
+    for (let i = 0; i < includes.length; i++) {
+        const includePattern = includes[i];
+        const matcher = picomatch(includePattern.pattern);
+        if (matcher(filePath)) {
+            return {
+                included: true,
+                matchedPattern: {
+                    pattern: includePattern.pattern,
+                    basePath: includePattern.basePath,
+                    index: i,
+                },
+            };
+        }
+    }
+    // No patterns matched
+    return { included: false, matchedPattern: null };
+}
+/**
+ * Get the headers needed to make a conditional request.
+ * Uses the etag and last-modified values from the meta store.
+ * @internal
+ */
+export function getHeaders({ init, meta, id, }) {
+    const tag = `${id}-etag`;
+    const lastModifiedTag = `${id}-last-modified`;
+    const etag = meta.get(tag);
+    const lastModified = meta.get(lastModifiedTag);
+    const headers = new Headers(init);
+    if (etag) {
+        headers.set("If-None-Match", etag);
+    }
+    else if (lastModified) {
+        headers.set("If-Modified-Since", lastModified);
+    }
+    return headers;
+}
+/**
+ * Store the etag or last-modified headers from a response in the meta store.
+ * @internal
+ */
+export function syncHeaders({ headers, meta, id, }) {
+    const etag = headers.get("etag");
+    const lastModified = headers.get("last-modified");
+    const tag = `${id}-etag`;
+    const lastModifiedTag = `${id}-last-modified`;
+    meta.delete(tag);
+    meta.delete(lastModifiedTag);
+    if (etag) {
+        meta.set(tag, etag);
+    }
+    else if (lastModified) {
+        meta.set(lastModifiedTag, lastModified);
+    }
+}

package/dist/github.storage.d.ts

@@ -0,0 +1,15 @@
+import type { ImportedFile } from "./github.link-transform.js";
+import type { ExtendedLoaderContext } from "./github.types.js";
+/**
+ * Ensures directory exists and writes file to disk.
+ * @internal
+ */
+export declare function syncFile(path: string, content: string): Promise<void>;
+/**
+ * Stores a processed file in Astro's content store
+ * @internal
+ */
+export declare function storeProcessedFile(file: ImportedFile, context: ExtendedLoaderContext, clear: boolean): Promise<{
+    id: string;
+    filePath: string;
+}>;

package/dist/github.storage.js

@@ -0,0 +1,109 @@
+import { existsSync, promises as fs } from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
+/**
+ * Ensures directory exists and writes file to disk.
+ * @internal
+ */
+export async function syncFile(path, content) {
+    const dir = path.substring(0, path.lastIndexOf("/"));
+    if (dir && !existsSync(dir)) {
+        await fs.mkdir(dir, { recursive: true });
+    }
+    await fs.writeFile(path, content, "utf-8");
+}
+/**
+ * Stores a processed file in Astro's content store
+ * @internal
+ */
+export async function storeProcessedFile(file, context, clear) {
+    const { store, generateDigest, entryTypes, logger, parseData, config } = context;
+    function configForFile(filePath) {
+        const ext = filePath.split(".").at(-1);
+        if (!ext) {
+            logger.warn(`No extension found for ${filePath}`);
+            return;
+        }
+        return entryTypes?.get(`.${ext}`);
+    }
+    const entryType = configForFile(file.sourcePath || "tmp.md");
+    if (!entryType)
+        throw new Error("No entry type found");
+    const fileUrl = pathToFileURL(file.targetPath);
+    const { body, data } = await entryType.getEntryInfo({
+        contents: file.content,
+        fileUrl: fileUrl,
+    });
+    // Generate digest for storage (repository-level caching handles change detection)
+    const digest = generateDigest(file.content);
+    const existingEntry = store.get(file.id);
+    if (existingEntry) {
+        logger.debug(`🔄 File ${file.id} - updating`);
+    }
+    else {
+        logger.debug(`📄 File ${file.id} - adding`);
+    }
+    // Write file to disk
+    if (!existsSync(fileURLToPath(fileUrl))) {
+        logger.verbose(`Writing ${file.id} to ${fileUrl}`);
+        await syncFile(fileURLToPath(fileUrl), file.content);
+    }
+    const parsedData = await parseData({
+        id: file.id,
+        data,
+        filePath: fileUrl.toString(),
+    });
+    // When clear mode is enabled, delete the existing entry before setting the new one.
+    // This provides atomic replacement without breaking Astro's content collection,
+    // as opposed to calling store.clear() which empties everything at once.
+    if (clear && existingEntry) {
+        logger.debug(`🗑️ Clearing existing entry before replacement: ${file.id}`);
+        store.delete(file.id);
+    }
+    // Store in content store
+    if (entryType.getRenderFunction) {
+        logger.verbose(`Rendering ${file.id}`);
+        const render = await entryType.getRenderFunction(config);
+        let rendered = undefined;
+        try {
+            rendered = await render?.({
+                id: file.id,
+                data,
+                body,
+                filePath: fileUrl.toString(),
+                digest,
+            });
+        }
+        catch (error) {
+            logger.error(`Error rendering ${file.id}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        logger.debug(`🔍 Storing collection entry: ${file.id} (${file.sourcePath} -> ${file.targetPath})`);
+        store.set({
+            id: file.id,
+            data: parsedData,
+            body,
+            filePath: file.targetPath,
+            digest,
+            rendered,
+        });
+    }
+    else if ("contentModuleTypes" in entryType) {
+        store.set({
+            id: file.id,
+            data: parsedData,
+            body,
+            filePath: file.targetPath,
+            digest,
+            deferredRender: true,
+        });
+    }
+    else {
+        store.set({
+            id: file.id,
+            data: parsedData,
+            body,
+            filePath: file.targetPath,
+            digest,
+        });
+    }
+    return { id: file.id, filePath: file.targetPath };
+}

package/dist/github.types.d.ts

@@ -3,7 +3,7 @@ import type { ContentEntryType } from "astro";
 import type { MarkdownHeading } from "@astrojs/markdown-remark";
 import { Octokit } from "octokit";
 import type { LinkHandler } from "./github.link-transform.js";
-import type { LogLevel } from "./github.logger.js";
+import type { LogLevel, Logger } from "./github.logger.js";
 /**
  * Context information for link transformations
  */
@@ -26,7 +26,7 @@ export interface LinkMapping {
     /** Pattern to match (string or regex) */
     pattern: string | RegExp;
     /** Replacement string or function */
-    replacement: string | ((match: string, anchor: string, context: any) => string);
+    replacement: string | ((match: string, anchor: string, context: LinkTransformContext) => string);
     /** Apply to all links, not just unresolved internal links (default: false) */
     global?: boolean;
     /** Function to determine if this mapping should apply to the current file context */
@@ -162,7 +162,7 @@ export type CollectionEntryOptions = {
      * The LoaderContext may contain properties and methods that offer
      * control or inspection over the loading behavior.
      */
-    context: LoaderContext;
+    context: ExtendedLoaderContext;
     /**
      * An instance of the Octokit library, which provides a way to interact
      * with GitHub's REST API. This variable allows you to access and perform
@@ -225,6 +225,16 @@ export interface RenderedContent {
         [key: string]: unknown;
     };
 }
+/**
+ * Represents a version of a library variant to display in the devportal's version picker.
+ * Versions are manually curated in the import config — no auto-discovery.
+ */
+export interface VersionConfig {
+    /** URL segment for this version (e.g., "latest", "v8.0.0") */
+    slug: string;
+    /** Display name for this version (e.g., "Latest", "v8.0.0") */
+    label: string;
+}
 /**
  * Represents configuration options for importing content from GitHub repositories.
  */
@@ -286,18 +296,38 @@ export type ImportOptions = {
      * @default 'default'
      */
     logLevel?: LogLevel;
+    /**
+     * Language for this import variant (e.g., "TypeScript", "Python", "Go").
+     * Used for logging and passed through to the devportal for UI display.
+     */
+    language?: string;
+    /**
+     * Versions to display in the devportal's version picker.
+     * Informational — tells the loader which version folders exist in the source content.
+     * The loader imports content as-is; the version folder structure carries through from source to destination.
+     */
+    versions?: VersionConfig[];
 };
 export type FetchOptions = RequestInit & {
     signal?: AbortSignal;
     concurrency?: number;
 };
 /**
- * @internal
+ * Astro loader context extended with optional entry type support.
+ * Use this type when calling `.load(context as LoaderContext)` in multi-loader patterns.
  */
 export interface LoaderContext extends AstroLoaderContext {
     /** @internal */
     entryTypes?: Map<string, ContentEntryType>;
 }
+/**
+ * LoaderContext with Astro's logger replaced by our Logger class.
+ * Used by internal functions that need verbose/logFileProcessing/etc.
+ * @internal
+ */
+export type ExtendedLoaderContext = Omit<LoaderContext, "logger"> & {
+    logger: Logger;
+};
 /**
  * @internal
  */

package/dist/index.d.ts

@@ -1,6 +1,8 @@
-export * from './github.auth.js';
-export * from './github.constants.js';
-export * from './github.content.js';
-export * from './github.loader.js';
-export * from './github.types.js';
-export * from './github.link-transform.js';
+export { githubLoader } from "./github.loader.js";
+export { createAuthenticatedOctokit, createOctokitFromEnv, } from "./github.auth.js";
+export type { GithubLoaderOptions, ImportOptions, FetchOptions, IncludePattern, PathMappingValue, EnhancedPathMapping, VersionConfig, LoaderContext, } from "./github.types.js";
+export type { TransformFunction, TransformContext, MatchedPattern, } from "./github.types.js";
+export type { LinkMapping, LinkTransformContext, ImportLinkTransformOptions, } from "./github.types.js";
+export type { LinkHandler } from "./github.link-transform.js";
+export type { GitHubAuthConfig, GitHubAppAuthConfig, GitHubPATAuthConfig, } from "./github.auth.js";
+export type { LogLevel } from "./github.logger.js";