@baeta/generator-sdk 2.0.0-next.1 → 2.0.0-next.2

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @baeta/generator-sdk
 
+## 2.0.0-next.2
+
+### Patch Changes
+
+- Fix broken types
+
+- Updated dependencies []:
+  - @baeta/util-path@2.0.0-next.2
+  - @baeta/plugin@2.0.0-next.2
+
 ## 2.0.0-next.1
 
 ### Patch Changes

package/dist/index.d.ts

@@ -0,0 +1,244 @@
+import { EventType, Options, Event } from '@parcel/watcher';
+import micromatch from 'micromatch';
+export { default as micromatch } from 'micromatch';
+import * as fs_promises from 'fs/promises';
+import { PluginType } from '@baeta/plugin';
+
+/**
+ * Options for generated files.
+ */
+interface FileOptions {
+    /**
+     * Disable generation notice at the beginning of the file.
+     * @defaultValue false
+     */
+    disableGenerationNoticeHeader?: boolean;
+    /**
+     * Disable eslint-disable comment at the beginning of the file.
+     * @defaultValue false
+     */
+    disableEslintHeader?: boolean;
+    /**
+     * Disable biome comment at the beginning of the file.
+     * @defaultValue false
+     */
+    disableBiomeHeader?: boolean;
+    /**
+     * Allow overwriting the file.
+     * @defaultValue true
+     */
+    allowOverwrite?: boolean;
+    /**
+     * Add custom header at the beginning of the file.
+     */
+    addHeader?: (name: string, content: string, tag: string) => string;
+    /**
+     * Edit the content of the file before writing it.
+     */
+    transformContent?: (name: string, content: string, tag: string) => string | Promise<string>;
+}
+declare class File {
+    persisted: boolean;
+    filename: string;
+    content: string;
+    tag: string;
+    private options?;
+    constructor(filename: string, content: string, tag: string, options?: FileOptions);
+    write: () => Promise<void>;
+    unlink: () => Promise<void>;
+    protected buildContent(): Promise<string>;
+    protected buildHeader(): string;
+    protected createComment(comment: string): string;
+}
+
+/**
+ * Interface for custom schema loaders.
+ */
+type GraphQlLoaderAny = any;
+interface Loader<TOptions = GraphQlLoaderAny> {
+    load(pointer: string, options?: TOptions): Promise<GraphQlLoaderAny[] | null | never>;
+    loadSync?(pointer: string, options?: TOptions): GraphQlLoaderAny[] | null | never;
+}
+/**
+ * Options for the Baeta Generator.
+ */
+interface GeneratorOptions {
+    /**
+     * Current working directory for resolving relative paths.
+     * @defaultValue process.cwd()
+     */
+    cwd?: string;
+    /**
+     * Glob pattern(s) to locate GraphQL schema files.
+     * @defaultValue ```ts
+     * ['src/∗∗/∗.gql', 'src/∗∗/∗.graphql']
+     * ```
+     */
+    schemas: string[];
+    /**
+     * Root directory where GraphQL modules are defined.
+     * @defaultValue 'src/modules'
+     */
+    modulesDir?: string;
+    /**
+     * Filename for the generated module definition file.
+     * Contains type definitions and the GraphQL AST.
+     * @defaultValue 'typedef.ts'
+     */
+    moduleDefinitionName?: string;
+    /**
+     * Output path for the generated type files.
+     * @defaultValue ```ts
+     * `${modulesDir}/../__generated__/types.ts`
+     * ```
+     */
+    typesDir?: string;
+    /**
+     * Configuration options for generated files.
+     */
+    fileOptions?: FileOptions;
+    /**
+     * Custom schema loaders for processing schema files.
+     */
+    loaders?: Loader[];
+    /**
+     * File extension to use in generated import statements.
+     * Set to false to omit extensions.
+     * @defaultValue '.ts'
+     */
+    importExtension?: '.js' | '.ts' | false;
+}
+interface NormalizedGeneratorOptions {
+    cwd: string;
+    schemas: string[];
+    modulesDir: string;
+    moduleDefinitionName: string;
+    typesDir: string;
+    fileOptions?: FileOptions;
+    loaders?: Loader[];
+    importExtension: '.js' | '.ts' | '';
+}
+declare function loadOptions(options: GeneratorOptions): NormalizedGeneratorOptions;
+
+declare class FileManager {
+    files: File[];
+    fileOptions?: FileOptions;
+    constructor(fileOptions?: FileOptions);
+    createAndAdd(filename: string, content: string, tag: string, options?: FileOptions): File;
+    add(...file: File[]): void;
+    get(filename: string): File | undefined;
+    getAll(): File[];
+    getByTag(tag: string): File[];
+    remove(filename: string): void;
+    removeAll(): void;
+    removeByTag(tag: string): void;
+    writeAll(): Promise<void[]>;
+    writeByTag(tag: string): Promise<void[]>;
+    unlinkAll(): Promise<void>;
+    getPersistedFiles(): File[];
+}
+
+type MatchFn = (testString: string) => boolean;
+type MatchPattern = string | RegExp | MatchFn;
+declare class WatcherIgnore {
+    private readonly cwd;
+    private files;
+    private regexps;
+    private functions;
+    private globs;
+    private globsMap;
+    constructor(cwd: string);
+    ignore(pattern: MatchPattern): void;
+    isMicromatch(pattern: string): boolean;
+    resolveFile(file: string): string;
+    unignore(pattern: MatchPattern): void;
+    isIgnored(path: string): boolean;
+}
+
+declare const isMatch: (string: string, pattern: string | readonly string[], options?: micromatch.Options) => boolean;
+type WatcherListener = (path: WatcherFile) => void;
+interface WatcherFile {
+    type: EventType;
+    path: string;
+    relativePath: string;
+}
+declare class Watcher {
+    private readonly cwd;
+    private readonly options?;
+    private subscription;
+    private listeners;
+    private watcherIgnore;
+    constructor(cwd: string, options?: Options);
+    onEvents: (err: Error | null, events: Event[]) => void;
+    on(event: EventType, listener: WatcherListener): void;
+    off(event: EventType, listener: WatcherListener): void;
+    ignore(pattern: MatchPattern): void;
+    unignore(pattern: MatchPattern): void;
+    createSubscription(): {
+        unsubscribe: () => Promise<void>;
+    };
+    close(): Promise<void>;
+}
+
+type Ctx<T = unknown> = {
+    fileManager: FileManager;
+    didSetup: string[];
+    didGenerate: string[];
+    didEnd: string[];
+    pluginNames: string[];
+    generatorOptions: NormalizedGeneratorOptions;
+    watching: boolean;
+    changedFile?: WatcherFile;
+} & T;
+
+declare class FileBlock extends File {
+    filename: string;
+    content: string;
+    start: string;
+    end: string;
+    tag: string;
+    constructor(filename: string, content: string, start: string, end: string, tag: string, options?: FileOptions);
+    write: () => Promise<void>;
+    unlink: () => Promise<void>;
+    protected getExistingContent(): Promise<readonly [string, fs_promises.FileHandle] | readonly ["", null]>;
+    protected getSlices(existingContent: string): readonly [string, "", false] | readonly [string, string, true];
+    protected addBlockToContent(existingContent: string): string;
+    protected buildPadding(existingContent: string): "" | "\n" | "\n\n";
+}
+
+declare function getModuleExportName(name: string): string;
+
+declare const GeneratorPluginVersion: {
+    readonly V1: "v1";
+};
+type GeneratorPluginVersion = (typeof GeneratorPluginVersion)[keyof typeof GeneratorPluginVersion];
+type GeneratorPluginV1Fn<Store = unknown> = (ctx: Ctx<Store>, next: () => Promise<void>) => Promise<void>;
+type GeneratorPluginV1ReloadFn = (file: WatcherFile) => void;
+type GeneratorPluginV1WatchOptions = (options: NormalizedGeneratorOptions, watcher: Watcher, reload: GeneratorPluginV1ReloadFn) => void;
+type GeneratorPluginV1Factory<Store = unknown> = {
+    name: string;
+    actionName: string;
+    setup?: GeneratorPluginV1Fn<Store>;
+    generate?: GeneratorPluginV1Fn<Store>;
+    end?: GeneratorPluginV1Fn<Store>;
+    watch?: GeneratorPluginV1WatchOptions;
+};
+interface GeneratorPluginV1<Store = unknown> {
+    name: string;
+    actionName: string;
+    version: typeof GeneratorPluginVersion.V1;
+    type: typeof PluginType.Generator;
+    setup: GeneratorPluginV1Fn<Store>;
+    generate: GeneratorPluginV1Fn<Store>;
+    end: GeneratorPluginV1Fn<Store>;
+    watch: GeneratorPluginV1WatchOptions;
+}
+declare function createPluginV1<Store = unknown>(options: GeneratorPluginV1Factory<Store>): GeneratorPluginV1<Store>;
+declare function isGeneratorPlugin(plugin: {
+    type: PluginType;
+}): plugin is GeneratorPluginV1<unknown>;
+declare function getGeneratorPlugins(plugins?: Array<{
+    type: PluginType;
+}>): GeneratorPluginV1<unknown>[];
+
+export { type Ctx, File, FileBlock, FileManager, type FileOptions, type GeneratorOptions, type GeneratorPluginV1, type GeneratorPluginV1Factory, type GeneratorPluginV1Fn, type GeneratorPluginV1ReloadFn, type GeneratorPluginV1WatchOptions, GeneratorPluginVersion, type Loader, type MatchFn, type MatchPattern, type NormalizedGeneratorOptions, Watcher, type WatcherFile, WatcherIgnore, type WatcherListener, createPluginV1, getGeneratorPlugins, getModuleExportName, isGeneratorPlugin, isMatch, loadOptions };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@baeta/generator-sdk",
-  "version": "2.0.0-next.1",
+  "version": "2.0.0-next.2",
   "keywords": [
     "baeta",
     "graphql",
@@ -43,8 +43,8 @@
     "types": "tsc --noEmit"
   },
   "dependencies": {
-    "@baeta/plugin": "^2.0.0-next.1",
-    "@baeta/util-path": "^2.0.0-next.1",
+    "@baeta/plugin": "^2.0.0-next.2",
+    "@baeta/util-path": "^2.0.0-next.2",
     "@parcel/watcher": "^2.5.1",
     "change-case-all": "2.1.0",
     "micromatch": "^4.0.8"