@knapsack/app/dist/domains/patterns/renderers/renderer-base.d.ts

Build Design Systems with Knapsack

import { type Except } from '@knapsack/utils';
import { type JsonSchemaObject, type RendererId, type PkgPathAliases, type KnapsackPattern, type TemplateSuggestionsGetFn, type KnapsackFile, type KnapsackPatternTemplate, type TemplateRendererMeta, type Demo, type KsRenderResults, type ContentStateForRendering, type TemplateInfo, type CodeSrc, type CodeSrcUserConfig, type DemoWithData, normalizeTemplateInfo, type RendererDiscovery, type PathPackage } from '@knapsack/types';
import { type PathAbsolute } from '@knapsack/file-utils';
import type { Creator } from '@knapsack/creator-utils';
import { log } from '../../../cli/log';
import { type CliLifecycle } from '../../../types/cli-lifecycle';
import type { RouteInspect } from '../../../types/endpoints';
export type RendererBaseHydrateData = {
    codeSrcs: Record<CodeSrc['path'], CodeSrc>;
};
export declare abstract class RendererBase<TheRendererId extends RendererId = RendererId, TheHydrateData extends RendererBaseHydrateData = RendererBaseHydrateData> implements CliLifecycle<RendererBaseHydrateData> {
    #private;
    id: TheRendererId;
    language: string;
    logPrefix: string;
    log: typeof log;
    /**
     * Aliases for package paths
     * Example:
     * ```js
     * {
     *   'my-pkg': '../path/to/my-pkg',
     * }
     * ```
     */
    pkgPathAliases?: PkgPathAliases;
    creators?: Creator[];
    codeSrcs: Map<PathPackage | import("@knapsack/types").PathPackageSubPath | import("@knapsack/types").PathRelative, CodeSrc>;
    codeSrcsUserConfig: CodeSrcUserConfig[];
    constructor({ id, language, codeSrcsUserConfig, }: {
        id: TheRendererId;
        language: string;
        codeSrcsUserConfig: CodeSrcUserConfig[];
    });
    /**
     * This is ran after constructor and before any other methods
     * We do this to pass in things that the users do no pass into the constructor in `knapsack.config.js`
     */
    setConfig({ userConfigDir, dataDir, }: {
        /**
         * directory path where `knapsack.config.js` can be found
         * non-absolute paths in `knapsack.config.js` will be relative from this
         */
        userConfigDir: PathAbsolute;
        dataDir: PathAbsolute;
    }): void;
    init(this: Renderer<TheRendererId, TheHydrateData>, _: Parameters<CliLifecycle['init']>[0]): ReturnType<CliLifecycle['init']>;
    build(this: Renderer<TheRendererId, RendererBaseHydrateData>): ReturnType<CliLifecycle<RendererBaseHydrateData>['build']>;
    hydrate(this: Renderer<TheRendererId>, { hydrateData, }: Parameters<CliLifecycle<RendererBaseHydrateData>['hydrate']>[0]): ReturnType<CliLifecycle<RendererBaseHydrateData>['hydrate']>;
    /**
     * directory path where `knapsack.config.js` can be found
     * non-absolute paths in `knapsack.config.js` will be relative from this
     */
    get userConfigDir(): PathAbsolute;
    get dataDir(): PathAbsolute;
    get outputDir(): PathAbsolute;
    get publicPath(): `/${string}/`;
    get hydrateDataFilePath(): string;
    onChange(): void;
    watch(this: Renderer<TheRendererId, RendererBaseHydrateData>): Promise<void>;
    changeCase: (str: string) => string;
    normalizeTemplateInfo(this: Renderer<TheRendererId, RendererBaseHydrateData>, opt: Except<Parameters<typeof normalizeTemplateInfo>[0], 'rendererId'>): TemplateInfo<TheRendererId>;
    normalizeDemo(this: Renderer<TheRendererId, RendererBaseHydrateData>, { demo, state, }: {
        demo: DemoWithData;
        state: ContentStateForRendering;
    }): TemplateInfo<TheRendererId>;
    resolvePath: (path: string | {
        path: string;
        resolveFromDir?: string;
    }) => Promise<{
        exists: boolean;
        absolutePath: PathAbsolute;
        originalPath: string;
        type: "absolute" | "relative" | "package" | "unknown";
    }>;
    /** @deprecated use async `resolvePath` instead */
    resolvePathSync: (path: string | {
        path: string;
        resolveFromDir?: string;
    }) => {
        exists: boolean;
        absolutePath: PathAbsolute;
        originalPath: string;
        type: "absolute" | "relative" | "package" | "unknown";
    };
    addCodeSrc({ path, relativePathsFrom, }: {
        path: string;
        relativePathsFrom?: 'data-dir' | 'config-file';
    }): Promise<void>;
    getCodeSrcs({ includePrototypePaths, }?: {
        includePrototypePaths?: boolean;
    }): CodeSrc[];
    abstract getDiscovery(this: Renderer<TheRendererId, RendererBaseHydrateData>): Promise<RendererDiscovery<TheRendererId>>;
    getUnusedTemplatePaths({ globPaths, state, cwd, }: {
        globPaths: string[];
        cwd?: string;
        state: ContentStateForRendering;
    }): Promise<{
        unusedPaths: string[];
        usedPaths: string[];
    }>;
    static convertSchemaToTypeScriptDefs({ schema, title, description, patternId, templateId, preBanner, postBanner, }: {
        schema: JsonSchemaObject;
        /**
         * Will become the `export`-ed `interface`
         */
        title: string;
        description?: string;
        patternId: string;
        templateId: string;
        preBanner?: string;
        postBanner?: string;
    }): Promise<string>;
    writeHydrateData: (data: TheHydrateData) => Promise<void>;
    readHydrateData: () => Promise<TheHydrateData>;
    abstract getMeta: () => TemplateRendererMeta;
}
export interface Renderable<TheRendererId extends RendererId = RendererId> {
    render(opt: {
        state: ContentStateForRendering;
        demo: Demo;
    }): Promise<KsRenderResults>;
    getUsage(opt: Parameters<Renderable['render']>[0]): Promise<string>;
    getTemplateSuggestions?(_opt: Parameters<TemplateSuggestionsGetFn>[0]): ReturnType<TemplateSuggestionsGetFn>;
    inspect?(templateInfo: TemplateInfo<TheRendererId>): Promise<RouteInspect['output']>;
    getTemplateMeta?(_opt: {
        pattern: KnapsackPattern;
        template: KnapsackPatternTemplate;
    }): Promise<KnapsackFile[]>;
    /**
     * The result of all the `getTemplateMeta` runs aggregated together
     * @see {Renderer['getTemplateMeta']}
     * @see getTemplateMeta
     * @see {getTemplateMeta}
     */
    alterTemplateMetaFiles?(opt: {
        files: KnapsackFile[];
        metaDir: string;
    }): Promise<KnapsackFile[]>;
}
export type Renderer<TheRendererId extends RendererId = RendererId, TheHydrateData extends RendererBaseHydrateData = RendererBaseHydrateData> = Renderable<TheRendererId> & RendererBase<TheRendererId, TheHydrateData> & CliLifecycle<TheHydrateData>;
//# sourceMappingURL=renderer-base.d.ts.map