@jungvonmatt/contentful-ssg 0.17.2 → 1.0.2

package/dist/converter/yaml.d.ts

@@ -0,0 +1,3 @@
+import { KeyValueMap } from '../types';
+export declare const stringify: <T = KeyValueMap<any>>(obj: T) => string;
+export declare const parse: <T = KeyValueMap<any>>(obj: string) => T;

package/dist/converter/yaml.js

@@ -0,0 +1,27 @@
+import yaml from 'js-yaml';
+const getPredicate = (type) => (data) => typeof data === 'string' && data.startsWith(`${type} `);
+const getRepresent = (type) => (data) => typeof data === 'string' ? data.replace(`${type} `, '') : JSON.stringify(data);
+const getConstruct = (type) => (data) => typeof data === 'string' ? `${type} ${data}` : `${type} ${typeof data}`;
+const growYamlConstructors = [
+    '!g.csv',
+    '!g.doc',
+    '!g.json',
+    '!g.static',
+    '!g.string',
+    '!g.url',
+    '!g.yaml',
+];
+const growYamlTypes = growYamlConstructors.map((type) => new yaml.Type(type, {
+    kind: 'scalar',
+    predicate: getPredicate(type),
+    represent: getRepresent(type),
+    construct: getConstruct(type),
+}));
+export const stringify = (obj) => {
+    const GROW_SCHEMA = yaml.DEFAULT_SCHEMA.extend(growYamlTypes);
+    return yaml.dump(obj, { schema: GROW_SCHEMA });
+};
+export const parse = (obj) => {
+    const GROW_SCHEMA = yaml.DEFAULT_SCHEMA.extend(growYamlTypes);
+    return yaml.load(obj, { schema: GROW_SCHEMA });
+};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import type { Config } from './types.js';
+export declare const run: (config: Config) => Promise<void>;

package/dist/index.js

@@ -0,0 +1,125 @@
+import Listr from 'listr';
+import chalk from 'chalk';
+import { getContentTypeId, getContentId } from './lib/contentful.js';
+import { setup } from './tasks/setup.js';
+import { fetch } from './tasks/fetch.js';
+import { localize } from './tasks/localize.js';
+import { transform } from './tasks/transform.js';
+import { write } from './tasks/write.js';
+import { collectParentValues, collectValues } from './lib/utils.js';
+import { ValidationError } from './lib/error.js';
+class CustomListrRenderer {
+    _tasks;
+    constructor(tasks) {
+        this._tasks = tasks;
+    }
+    static get nonTTY() {
+        return false;
+    }
+    static subscribeTasks(tasks, indent = '') {
+        for (const task of tasks) {
+            task.subscribe((event) => {
+                if (event.type === 'STATE' && task.isPending()) {
+                    console.log(`${indent}  ${chalk.yellow('\u279E')} ${task.title}`);
+                }
+                if (event.type === 'SUBTASKS' && task.subtasks.length > 0) {
+                    CustomListrRenderer.subscribeTasks(task.subtasks, indent + '  ');
+                }
+            });
+        }
+    }
+    render() {
+        CustomListrRenderer.subscribeTasks(this._tasks);
+    }
+    end(err) {
+        if (!err) {
+            console.log(`  ${chalk.green('✔')} all tasks done!`);
+        }
+    }
+}
+export const run = async (config) => {
+    const tasks = new Listr([
+        {
+            title: 'Setup',
+            task: async (ctx) => setup(ctx, config),
+        },
+        {
+            title: 'Pulling data from contentful',
+            task: async (ctx) => fetch(ctx, config),
+        },
+        {
+            title: 'Localize data',
+            task: async (ctx) => localize(ctx),
+        },
+        {
+            title: 'Before Hook',
+            skip: (ctx) => !ctx.hooks.has('before'),
+            task: async (ctx) => {
+                const result = await ctx.hooks.before();
+                ctx = { ...ctx, ...(result || {}) };
+            },
+        },
+        {
+            title: 'Writing files',
+            task: async (ctx) => {
+                const { locales = [] } = ctx.data;
+                const tasks = locales.map((locale) => ({
+                    title: `${locale.code}`,
+                    task: async () => {
+                        const data = ctx.localized.get(locale.code);
+                        const { entries = [] } = data || {};
+                        const promises = entries.map(async (entry) => {
+                            const id = getContentId(entry);
+                            const contentTypeId = getContentTypeId(entry);
+                            const utils = {
+                                collectValues: collectValues({ ...data, entry }),
+                                collectParentValues: collectParentValues({ ...data, entry }),
+                            };
+                            const transformContext = {
+                                ...data,
+                                id,
+                                contentTypeId,
+                                entry,
+                                locale,
+                                utils,
+                            };
+                            try {
+                                const content = await transform(transformContext, ctx, config);
+                                if (typeof content === 'undefined') {
+                                    return;
+                                }
+                                await write({ ...transformContext, content }, ctx, config);
+                                ctx.stats.addSuccess(transformContext);
+                            }
+                            catch (error) {
+                                if (error instanceof ValidationError) {
+                                    ctx.stats.addSkipped(transformContext, error);
+                                }
+                                else if (typeof error === 'string' || error instanceof Error) {
+                                    ctx.stats.addError(transformContext, error);
+                                }
+                            }
+                        });
+                        return Promise.all(promises);
+                    },
+                }));
+                return new Listr(tasks, { concurrent: true });
+            },
+        },
+        {
+            title: 'After Hook',
+            skip: (ctx) => !ctx.hooks.has('after'),
+            task: async (ctx) => {
+                const result = await ctx.hooks.after();
+                ctx = { ...ctx, ...(result || {}) };
+            },
+        },
+        {
+            title: 'Cleanup',
+            task: async (ctx) => ctx.fileManager.cleanup(),
+        },
+    ], { renderer: CustomListrRenderer });
+    const ctx = await tasks.run();
+    await ctx.stats.print();
+    console.log('\n---------------------------------------------');
+};

package/dist/lib/array.d.ts

@@ -0,0 +1,4 @@
+export declare function mapAsync<T, U>(iterable: T[], callback: (value: T, index?: number, iterable?: T[]) => U | Promise<U>): Promise<U[]>;
+export declare function forEachAsync<T>(iterable: T[], callback: (value: T, index?: number, iterable?: T[]) => void | Promise<void>): Promise<void>;
+export declare function filterAsync<T>(iterable: T[], callback: (value: T, index?: number, array?: T[]) => boolean | Promise<boolean>): Promise<T[]>;
+export declare function reduceAsync<T, U>(iterable: T[], callback: (previousValue: U, currentValue: T, currentIndex?: number, array?: T[]) => U | Promise<U>, initialValue?: U): Promise<U>;

package/dist/lib/array.js

@@ -0,0 +1,25 @@
+function series(reducer, initialValue) {
+    return async (iterable) => iterable.reduce(async (chain, value, key) => chain.then(async (results) => reducer(results, value, key, iterable)), Promise.resolve(initialValue));
+}
+export async function mapAsync(iterable, callback) {
+    const result = [];
+    const promises = iterable.map(async (item, index, array) => callback(item, index, array));
+    for await (const mapped of promises) {
+        result.push(mapped);
+    }
+    return result;
+}
+export async function forEachAsync(iterable, callback) {
+    for (const index of iterable.keys()) {
+        await callback(iterable[index], index, iterable);
+    }
+}
+export async function filterAsync(iterable, callback) {
+    return Promise.resolve(iterable).then(async (array) => array.reduce(async (chain, value, key) => chain.then(async (results) => {
+        const active = await callback(value, key, iterable);
+        return active ? [...results, value] : results;
+    }), Promise.resolve([])));
+}
+export async function reduceAsync(iterable, callback, initialValue) {
+    return Promise.resolve(iterable).then(series(callback, initialValue));
+}

package/dist/lib/config.d.ts

@@ -0,0 +1,3 @@
+import type { Config, ContentfulConfig } from '../types.js';
+export declare const getEnvironmentConfig: () => ContentfulConfig;
+export declare const getConfig: (args?: Partial<Config>) => Promise<Config>;

package/dist/lib/config.js

@@ -0,0 +1,144 @@
+import { register } from '@swc-node/register/register';
+import chalk from 'chalk';
+import { cosmiconfig } from 'cosmiconfig';
+import mergeOptionsModule from 'merge-options';
+import { dirname, isAbsolute, resolve } from 'path';
+import slash from 'slash';
+import { createRequire } from './create-require.js';
+import { isObject, removeEmpty } from './object.js';
+const typescriptLoader = async (filePath) => {
+    register({ format: 'esm', extensions: ['.ts', '.tsx', '.mts'] });
+    const require = createRequire();
+    const configModule = require(filePath);
+    return configModule.default || configModule;
+};
+const mergeOptions = mergeOptionsModule.bind({ ignoreUndefined: true });
+const resolvePlugin = async (plugin, config) => {
+    let pluginName;
+    let pluginOptions;
+    if (typeof plugin === 'string') {
+        pluginName = plugin;
+        pluginOptions = {};
+    }
+    else if (Array.isArray(plugin)) {
+        pluginName = plugin[0];
+        pluginOptions = plugin[1] || {};
+    }
+    else {
+        pluginName = plugin.resolve;
+        pluginOptions = plugin.options || {};
+    }
+    const { rootDir, verbose } = config;
+    try {
+        const requireSource = rootDir === null ? createRequire() : createRequire(`${rootDir}/:internal:`);
+        const resolvedPath = slash(requireSource.resolve(pluginName));
+        const pluginModule = (await import(resolvedPath));
+        let pluginDefaultHooks = {};
+        if (typeof pluginModule.default === 'function') {
+            pluginDefaultHooks = await pluginModule.default(pluginOptions || {});
+        }
+        else if (isObject(pluginModule.default)) {
+            pluginDefaultHooks = pluginModule.default;
+        }
+        const pluginHooks = { ...(pluginDefaultHooks || {}), ...(pluginModule || {}) };
+        return pluginHooks;
+    }
+    catch (error) {
+        if (verbose) {
+            console.error(chalk.red(`Plugin "${pluginName} threw the following error:`));
+            console.error(error);
+        }
+        else {
+            console.error(chalk.red(`There was a problem loading plugin "${pluginName}". Perhaps you need to install its package?\nUse --verbose to see actual error.`));
+        }
+        process.exit(1);
+    }
+};
+const loadConfig = async (moduleName) => {
+    const explorer = cosmiconfig(moduleName, {
+        searchPlaces: [
+            'package.json',
+            `.${moduleName}rc`,
+            `.${moduleName}rc.json`,
+            `.${moduleName}rc.yaml`,
+            `.${moduleName}rc.yml`,
+            `.${moduleName}rc.js`,
+            `${moduleName}.config.ts`,
+            `${moduleName}.config.js`,
+        ],
+        loaders: {
+            '.ts': typescriptLoader,
+        },
+    });
+    return explorer.search();
+};
+export const getEnvironmentConfig = () => removeEmpty({
+    spaceId: process.env.CONTENTFUL_SPACE_ID,
+    environmentId: process.env.CONTENTFUL_ENVIRONMENT_ID,
+    managementToken: process.env.CONTENTFUL_MANAGEMENT_TOKEN,
+    previewAccessToken: process.env.CONTENTFUL_PREVIEW_TOKEN,
+    accessToken: process.env.CONTENTFUL_DELIVERY_TOKEN,
+});
+export const getConfig = async (args) => {
+    const defaultOptions = {
+        environmentId: 'master',
+        host: 'api.contentful.com',
+        directory: resolve(process.cwd(), 'content'),
+        plugins: [],
+        resolvedPlugins: [],
+    };
+    const environmentOptions = getEnvironmentConfig();
+    let contentfulCliOptions = {};
+    try {
+        const contentfulConfig = await loadConfig('contentful');
+        if (!contentfulConfig.isEmpty) {
+            const { managementToken, activeSpaceId, activeEnvironmentId, host } = contentfulConfig.config;
+            contentfulCliOptions = removeEmpty({
+                spaceId: activeSpaceId,
+                managementToken,
+                environmentId: activeEnvironmentId,
+                host,
+            });
+        }
+    }
+    catch (error) {
+        if (typeof error === 'string') {
+            console.log('Error (Contentful):', error);
+        }
+        else if (error instanceof Error) {
+            console.log('Error (Contentful):', error.message);
+        }
+        else {
+            console.log(error);
+        }
+    }
+    let configFileOptions = {};
+    args.rootDir = process.cwd();
+    try {
+        const configFile = await loadConfig('contentful-ssg');
+        if (!configFile.isEmpty) {
+            configFileOptions = configFile.config;
+            args.rootDir = dirname(configFile.filepath);
+            if (configFileOptions.directory && !isAbsolute(configFileOptions.directory)) {
+                configFileOptions.directory = resolve(args.rootDir, configFileOptions.directory);
+            }
+        }
+    }
+    catch (error) {
+        if (typeof error === 'string') {
+            console.log('Error:', error);
+        }
+        else if (error instanceof Error) {
+            console.log('Error:', error.message);
+        }
+        else {
+            console.log(error);
+        }
+    }
+    const result = mergeOptions(defaultOptions, contentfulCliOptions, environmentOptions, configFileOptions, args || {});
+    const resolvedPlugins = [
+        ...result.resolvedPlugins,
+        ...(await Promise.all((result.plugins || []).map(async (plugin) => resolvePlugin(plugin, result)))),
+    ];
+    return { ...result, resolvedPlugins };
+};

package/dist/lib/contentful.d.ts

@@ -0,0 +1,40 @@
+import type { Space } from 'contentful-management/types';
+import type { ContentfulConfig, FieldSettings, Node, Entry, ContentType } from '../types.js';
+import contentful from 'contentful';
+export declare const FIELD_TYPE_SYMBOL = "Symbol";
+export declare const FIELD_TYPE_TEXT = "Text";
+export declare const FIELD_TYPE_RICHTEXT = "RichText";
+export declare const FIELD_TYPE_NUMBER = "Number";
+export declare const FIELD_TYPE_INTEGER = "Integer";
+export declare const FIELD_TYPE_DATE = "Date";
+export declare const FIELD_TYPE_LOCATION = "Location";
+export declare const FIELD_TYPE_ARRAY = "Array";
+export declare const FIELD_TYPE_BOOLEAN = "Boolean";
+export declare const FIELD_TYPE_LINK = "Link";
+export declare const FIELD_TYPE_OBJECT = "Object";
+export declare const LINK_TYPE_ASSET = "Asset";
+export declare const LINK_TYPE_ENTRY = "Entry";
+export declare const MAX_ALLOWED_LIMIT = 1000;
+export declare const getContentTypeId: <T extends contentful.Asset | Entry | contentful.Entry<unknown>>(node: T) => string;
+export declare const getEnvironmentId: <T extends Node>(node: T) => string;
+export declare const getContentId: <T extends contentful.ContentType | contentful.Asset | Entry | contentful.Entry<unknown>>(node: T) => string;
+export declare const getSpaces: (options: ContentfulConfig) => Promise<Space[]>;
+export declare const getSpace: (options: ContentfulConfig) => Promise<Space>;
+export declare const getEnvironments: (options: ContentfulConfig) => Promise<import("contentful-management/types").Environment[]>;
+export declare const getEnvironment: (options: ContentfulConfig) => Promise<import("contentful-management/types").Environment>;
+export declare const getApiKey: (options: ContentfulConfig) => Promise<string>;
+export declare const getPreviewApiKey: (options: ContentfulConfig) => Promise<string>;
+export declare const getContent: (options: ContentfulConfig) => Promise<{
+    entries: Entry[];
+    assets: contentful.Asset[];
+    contentTypes: contentful.ContentType[];
+    locales: contentful.Locale[];
+}>;
+export declare const isContentfulObject: (obj: any) => boolean;
+export declare const isLink: (obj: any) => boolean;
+export declare const isAssetLink: (obj: any) => boolean;
+export declare const isEntryLink: (obj: any) => boolean;
+export declare const isAsset: (obj: any) => boolean;
+export declare const isEntry: (obj: any) => boolean;
+export declare const getFieldSettings: (contentTypes: ContentType[]) => FieldSettings;
+export declare const convertToMap: <T extends Node>(nodes?: T[]) => Map<string, T>;

package/dist/lib/contentful.js

@@ -0,0 +1,145 @@
+import contentful from 'contentful';
+import contentfulManagement from 'contentful-management';
+let client;
+let managementClient;
+export const FIELD_TYPE_SYMBOL = 'Symbol';
+export const FIELD_TYPE_TEXT = 'Text';
+export const FIELD_TYPE_RICHTEXT = 'RichText';
+export const FIELD_TYPE_NUMBER = 'Number';
+export const FIELD_TYPE_INTEGER = 'Integer';
+export const FIELD_TYPE_DATE = 'Date';
+export const FIELD_TYPE_LOCATION = 'Location';
+export const FIELD_TYPE_ARRAY = 'Array';
+export const FIELD_TYPE_BOOLEAN = 'Boolean';
+export const FIELD_TYPE_LINK = 'Link';
+export const FIELD_TYPE_OBJECT = 'Object';
+export const LINK_TYPE_ASSET = 'Asset';
+export const LINK_TYPE_ENTRY = 'Entry';
+export const MAX_ALLOWED_LIMIT = 1000;
+export const getContentTypeId = (node) => node?.sys?.contentType?.sys?.id ?? 'unknown';
+export const getEnvironmentId = (node) => node?.sys?.environment?.sys?.id ?? 'unknown';
+export const getContentId = (node) => node?.sys?.id ?? 'unknown';
+const getClient = (options) => {
+    const { accessToken, previewAccessToken, spaceId, environmentId, preview } = options || {};
+    if (client) {
+        return client;
+    }
+    if (accessToken) {
+        const params = {
+            space: spaceId,
+            host: preview ? 'preview.contentful.com' : 'cdn.contentful.com',
+            accessToken: preview ? previewAccessToken : accessToken,
+            environment: environmentId,
+        };
+        return contentful.createClient(params);
+    }
+    throw new Error('You need to login first. Run npx contentful login');
+};
+const getManagementClient = (options) => {
+    const { managementToken } = options || {};
+    if (managementClient) {
+        return managementClient;
+    }
+    if (managementToken) {
+        return contentfulManagement.createClient({
+            accessToken: managementToken,
+        });
+    }
+    throw new Error('You need to login first. Run npx contentful login');
+};
+export const getSpaces = async (options) => {
+    const client = getManagementClient(options);
+    const { items: spaces } = await client.getSpaces();
+    return spaces;
+};
+export const getSpace = async (options) => {
+    const { spaceId } = options || {};
+    const client = getManagementClient(options);
+    return client.getSpace(spaceId);
+};
+export const getEnvironments = async (options) => {
+    const space = await getSpace(options);
+    const { items: environments } = await space.getEnvironments();
+    return environments;
+};
+export const getEnvironment = async (options) => {
+    const { environmentId, spaceId } = options || {};
+    const space = await getSpace(options);
+    const { items: environments } = await space.getEnvironments();
+    const environmentIds = (environments || []).map((env) => env.sys.id);
+    if (environmentId && environmentIds.includes(environmentId)) {
+        return space.getEnvironment(environmentId);
+    }
+    if (environmentId && !environmentIds.includes(environmentId)) {
+        throw new Error(`Environment "${environmentId}" is not available in space ${spaceId}"`);
+    }
+    throw new Error('Missing required parameter: environmentId');
+};
+export const getApiKey = async (options) => {
+    const space = await getSpace(options);
+    const { items: apiKeys = [] } = (await space.getApiKeys()) || {};
+    const [apiKey] = apiKeys;
+    const { accessToken } = apiKey || {};
+    return accessToken;
+};
+export const getPreviewApiKey = async (options) => {
+    const space = await getSpace(options);
+    const { items: previewApiKeys = [] } = await space.getPreviewApiKeys();
+    const [previewApiKey] = previewApiKeys;
+    const { accessToken: previewAccessToken } = previewApiKey;
+    return previewAccessToken;
+};
+const pagedGet = async (apiClient, { method, skip = 0, aggregatedResponse = null, query = null }) => {
+    const fullQuery = {
+        skip,
+        limit: MAX_ALLOWED_LIMIT,
+        order: 'sys.createdAt,sys.id',
+        locale: '*',
+        include: 0,
+        ...(query || {}),
+    };
+    const response = (await apiClient[method](fullQuery));
+    if (aggregatedResponse) {
+        aggregatedResponse.items = aggregatedResponse.items.concat(response.items);
+    }
+    else {
+        aggregatedResponse = response;
+    }
+    if (skip + MAX_ALLOWED_LIMIT <= response.total) {
+        return pagedGet(apiClient, {
+            method,
+            skip: skip + MAX_ALLOWED_LIMIT,
+            aggregatedResponse,
+            query,
+        });
+    }
+    return aggregatedResponse;
+};
+export const getContent = async (options) => {
+    const apiClient = getClient(options);
+    const { items: locales } = await pagedGet(apiClient, {
+        method: 'getLocales',
+    });
+    const { items: contentTypes } = await pagedGet(apiClient, {
+        method: 'getContentTypes',
+    });
+    const { items: entries } = await pagedGet(apiClient, {
+        method: 'getEntries',
+    });
+    const { items: assets } = await pagedGet(apiClient, {
+        method: 'getAssets',
+    });
+    return { entries, assets, contentTypes, locales };
+};
+export const isContentfulObject = (obj) => Object.prototype.toString.call(obj) === '[object Object]' && Object.keys(obj).includes('sys');
+export const isLink = (obj) => isContentfulObject(obj) && obj.sys.type === FIELD_TYPE_LINK;
+export const isAssetLink = (obj) => isLink(obj) && obj.sys.linkType === LINK_TYPE_ASSET;
+export const isEntryLink = (obj) => isContentfulObject(obj) && obj.sys.linkType === LINK_TYPE_ENTRY;
+export const isAsset = (obj) => isContentfulObject(obj) && obj.sys.type === LINK_TYPE_ASSET;
+export const isEntry = (obj) => isContentfulObject(obj) && obj.sys.type === LINK_TYPE_ENTRY;
+export const getFieldSettings = (contentTypes) => contentTypes.reduce((res, contentType) => {
+    const id = getContentId(contentType);
+    const fields = contentType.fields.reduce((fields, field) => ({ ...fields, [field.id]: field }), {});
+    return { ...res, [id]: fields };
+}, {});
+export const convertToMap = (nodes = []) => new Map(nodes.map((node) => [getContentId(node), node]));

package/dist/lib/create-require.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="node" />
+export declare const createRequire: (rootDir?: string) => NodeRequire;

package/dist/lib/create-require.js

@@ -0,0 +1,4 @@
+import { createRequire as moduleCreateRequire } from 'module';
+export const createRequire = (rootDir = null) => rootDir === null
+    ? moduleCreateRequire(import.meta.url)
+    : moduleCreateRequire(`${rootDir}/:internal:`);

package/dist/lib/error.d.ts

@@ -0,0 +1,9 @@
+import { ErrorEntry } from '../types';
+export declare class ValidationError extends Error {
+    missingFields: string[];
+    link: string;
+    entryId: string;
+    contentTypeId: string;
+    locale: string;
+    constructor(entry: ErrorEntry);
+}

package/dist/lib/error.js

@@ -0,0 +1,17 @@
+export class ValidationError extends Error {
+    missingFields;
+    link;
+    entryId;
+    contentTypeId;
+    locale;
+    constructor(entry) {
+        const message = `ValidationError: Invalid entry ${entry.entryId} for locale ${entry.locale.name}`;
+        super(message);
+        this.link = `https://app.contentful.com/spaces/${entry.spaceId}/environments/${entry.environmentId}/entries/${entry.entryId}`;
+        this.entryId = entry.entryId;
+        this.contentTypeId = entry.contentTypeId;
+        this.locale = entry.locale.code;
+        this.missingFields = entry.missingFields;
+        this.name = 'ValidationError';
+    }
+}

package/dist/lib/file-manager.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+import type { WriteFileOptions } from 'fs-extra';
+import type { Config, Ignore } from '../types';
+export declare class FileManager {
+    ignoreBase: string;
+    ignore?: Ignore;
+    files: Set<string>;
+    config: Config;
+    constructor(config: Config);
+    get count(): number;
+    get ignoredFiles(): string[];
+    initialize(): Promise<void>;
+    writeFile(file: string, data: any, options?: WriteFileOptions | BufferEncoding | string): Promise<void>;
+    deleteFile(file: string): Promise<void>;
+    removeEmptyDirectories(directory: string): Promise<void>;
+    cleanup(): Promise<boolean>;
+}

package/dist/lib/file-manager.js

@@ -0,0 +1,64 @@
+import { dirname, resolve, relative, join } from 'path';
+import ignore from 'ignore';
+import { readFile, readdir, lstat } from 'fs/promises';
+import { remove, outputFile } from 'fs-extra';
+export class FileManager {
+    ignoreBase = process.cwd();
+    ignore;
+    files = new Set();
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    get count() {
+        return [...this.ignoredFiles].length;
+    }
+    get ignoredFiles() {
+        return [...this.files].filter((file) => !this.ignore || this.ignore.ignores(relative(this.ignoreBase, file)));
+    }
+    async initialize() {
+        const { findUp } = await import('find-up');
+        const { globby } = await import('globby');
+        const gitignore = await findUp('.gitignore');
+        if (gitignore) {
+            this.ignoreBase = dirname(gitignore);
+            const ignorePatterns = await readFile(gitignore);
+            this.ignore = ignore().add(ignorePatterns.toString('utf8'));
+        }
+        const existing = await globby(`${this.config.directory}/**/*.*`);
+        this.files = new Set(existing.map((file) => resolve(file)));
+    }
+    async writeFile(file, data, options) {
+        await outputFile(file, data, options);
+        if (this.files.has(resolve(file))) {
+            this.files.delete(resolve(file));
+        }
+    }
+    async deleteFile(file) {
+        if (this.files.has(resolve(file))) {
+            this.files.delete(resolve(file));
+        }
+        return remove(file);
+    }
+    async removeEmptyDirectories(directory) {
+        const fileStats = await lstat(directory);
+        if (!fileStats.isDirectory()) {
+            return;
+        }
+        let fileNames = await readdir(directory);
+        if (fileNames.length > 0) {
+            const recursiveRemovalPromises = fileNames.map(async (fileName) => this.removeEmptyDirectories(join(directory, fileName)));
+            await Promise.all(recursiveRemovalPromises);
+            fileNames = await readdir(directory);
+        }
+        if (fileNames.length === 0 && directory !== this.config.directory) {
+            await remove(directory);
+        }
+    }
+    async cleanup() {
+        const promises = [...this.ignoredFiles].map(async (file) => this.deleteFile(file));
+        await Promise.allSettled(promises);
+        await this.removeEmptyDirectories(this.config.directory);
+        return true;
+    }
+}

package/dist/lib/hook-manager.d.ts

@@ -0,0 +1,15 @@
+import type { KeyValueMap, Config, Hooks, RuntimeContext, TransformContext } from '../types.js';
+export declare class HookManager {
+    runtimeContext: RuntimeContext;
+    config: Config;
+    constructor(runtimeContext: RuntimeContext, config: Config);
+    has(key: keyof Hooks): boolean;
+    before(defauleValue?: KeyValueMap): Promise<RuntimeContext>;
+    after(defauleValue?: KeyValueMap): Promise<RuntimeContext>;
+    transform(transformContext: TransformContext, defauleValue?: unknown): Promise<KeyValueMap<any>>;
+    mapMetaFields(transformContext: TransformContext, defauleValue?: unknown): Promise<KeyValueMap<any>>;
+    mapDirectory(transformContext: TransformContext, defauleValue?: unknown): Promise<string>;
+    mapFilename(transformContext: TransformContext, defauleValue?: unknown): Promise<string>;
+    mapAssetLink(transformContext: TransformContext, defauleValue?: unknown): Promise<KeyValueMap<any>>;
+    mapEntryLink(transformContext: TransformContext, defauleValue?: unknown): Promise<KeyValueMap<any>>;
+}