@najemi-software/typed-scss-modules 10.3.0

package/dist/lib/core/index.d.ts

@@ -0,0 +1,6 @@
+export { alerts, setAlertsLogLevel } from "./alerts.js";
+export { generate } from "./generate.js";
+export { listDifferent } from "./list-different.js";
+export type { CLIOptions, ConfigOptions } from "./types.js";
+export { watch } from "./watch.js";
+export { writeFile } from "./write-file.js";

package/dist/lib/core/index.js

@@ -0,0 +1,5 @@
+export { alerts, setAlertsLogLevel } from "./alerts.js";
+export { generate } from "./generate.js";
+export { listDifferent } from "./list-different.js";
+export { watch } from "./watch.js";
+export { writeFile } from "./write-file.js";

package/dist/lib/core/list-different.d.ts

@@ -0,0 +1,3 @@
+import type { ConfigOptions } from "./types.js";
+export declare const listDifferent: (pattern: string, options: ConfigOptions) => Promise<void>;
+export declare const checkFile: (file: string, options: ConfigOptions) => Promise<boolean>;

package/dist/lib/core/list-different.js

@@ -0,0 +1,42 @@
+import fs from "fs";
+import { fileToClassNames } from "../sass/file-to-class-names.js";
+import { classNamesToTypeDefinitions, getTypeDefinitionPath, } from "../typescript/index.js";
+import { alerts } from "./alerts.js";
+import { listFilesAndPerformSanityChecks } from "./list-files-and-perform-sanity-checks.js";
+export const listDifferent = async (pattern, options) => {
+    const files = listFilesAndPerformSanityChecks(pattern, options);
+    // Wait for all the files to be checked.
+    const validChecks = await Promise.all(files.map((file) => checkFile(file, options)));
+    if (validChecks.includes(false)) {
+        process.exit(1);
+    }
+};
+export const checkFile = async (file, options) => {
+    try {
+        const classNames = await fileToClassNames(file, options);
+        const typeDefinition = await classNamesToTypeDefinitions({
+            classNames: classNames,
+            file,
+            ...options,
+        });
+        if (!typeDefinition) {
+            // Assume if no type defs are necessary it's fine
+            return true;
+        }
+        const path = getTypeDefinitionPath(file, options);
+        if (!fs.existsSync(path)) {
+            alerts.error(`[INVALID TYPES] Type file needs to be generated for ${file} `);
+            return false;
+        }
+        const content = fs.readFileSync(path, { encoding: "utf8" });
+        if (content !== typeDefinition) {
+            alerts.error(`[INVALID TYPES] Check type definitions for ${file}`);
+            return false;
+        }
+        return true;
+    }
+    catch (error) {
+        alerts.error(`An error occurred checking ${file}:\n${JSON.stringify(error)}`);
+        return false;
+    }
+};

package/dist/lib/core/list-files-and-perform-sanity-checks.d.ts

@@ -0,0 +1,9 @@
+import type { ConfigOptions } from "./types.js";
+/**
+ * Return the files matching the given pattern and alert the user if only 0 or 1
+ * files matched.
+ *
+ * @param pattern the file pattern to generate type definitions for
+ * @param options the CLI options
+ */
+export declare function listFilesAndPerformSanityChecks(pattern: string, options: ConfigOptions): string[];

package/dist/lib/core/list-files-and-perform-sanity-checks.js

@@ -0,0 +1,22 @@
+import { globSync } from "glob";
+import { alerts } from "./alerts.js";
+/**
+ * Return the files matching the given pattern and alert the user if only 0 or 1
+ * files matched.
+ *
+ * @param pattern the file pattern to generate type definitions for
+ * @param options the CLI options
+ */
+export function listFilesAndPerformSanityChecks(pattern, options) {
+    // Find all the files that match the provided pattern.
+    const files = globSync(pattern, { ignore: options.ignore });
+    if (!files || !files.length) {
+        alerts.error("No files found.");
+    }
+    // This case still works as expected but it's easy to do on accident so
+    // provide a (hopefully) helpful warning.
+    if (files.length === 1) {
+        alerts.warn(`Only 1 file found for ${pattern}. If using a glob pattern (eg: dir/**/*.scss) make sure to wrap in quotes (eg: "dir/**/*.scss").`);
+    }
+    return files;
+}

package/dist/lib/core/remove-file.d.ts

@@ -0,0 +1,7 @@
+import type { ConfigOptions } from "./types.js";
+/**
+ * Given a single file remove the generated types if they exist
+ *
+ * @param file the SCSS file to generate types for
+ */
+export declare const removeSCSSTypeDefinitionFile: (file: string, options: ConfigOptions) => void;

package/dist/lib/core/remove-file.js

@@ -0,0 +1,28 @@
+import fs from "fs";
+import { getTypeDefinitionPath } from "../typescript/get-type-definition-path.js";
+import { alerts } from "./alerts.js";
+/**
+ * Given a single file remove the file
+ *
+ * @param file any file to remove
+ */
+const removeFile = (file) => {
+    try {
+        if (fs.existsSync(file)) {
+            fs.unlinkSync(file);
+            alerts.success(`[REMOVED] ${file}`);
+        }
+    }
+    catch (error) {
+        alerts.error(`An error occurred removing ${file}:\n${JSON.stringify(error)}`);
+    }
+};
+/**
+ * Given a single file remove the generated types if they exist
+ *
+ * @param file the SCSS file to generate types for
+ */
+export const removeSCSSTypeDefinitionFile = (file, options) => {
+    const path = getTypeDefinitionPath(file, options);
+    removeFile(path);
+};

package/dist/lib/core/types.d.ts

@@ -0,0 +1,21 @@
+import type { SASSOptions } from "../sass/file-to-class-names.js";
+import type { ExportType, LogLevel, QuoteType } from "../typescript/index.js";
+type CLIOnlyOptions = Extract<keyof SASSOptions, "importer">;
+export interface CLIOptions extends Exclude<SASSOptions, CLIOnlyOptions> {
+    banner: string;
+    ignore: string[];
+    ignoreInitial: boolean;
+    exportType: ExportType;
+    exportTypeName: string;
+    exportTypeInterface: string;
+    listDifferent: boolean;
+    quoteType: QuoteType;
+    updateStaleOnly: boolean;
+    watch: boolean;
+    logLevel: LogLevel;
+    outputFolder: string | null;
+    allowArbitraryExtensions: boolean;
+}
+export interface ConfigOptions extends CLIOptions, SASSOptions {
+}
+export {};

package/dist/lib/core/types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/core/watch.d.ts

@@ -0,0 +1,8 @@
+import type { ConfigOptions } from "./types.js";
+/**
+ * Watch a file glob and generate the corresponding types.
+ *
+ * @param pattern the file pattern to watch for file changes or additions
+ * @param options the CLI options
+ */
+export declare const watch: (pattern: string, options: ConfigOptions) => void;

package/dist/lib/core/watch.js

@@ -0,0 +1,34 @@
+import chok from "chokidar";
+import { alerts } from "./alerts.js";
+import { listFilesAndPerformSanityChecks } from "./list-files-and-perform-sanity-checks.js";
+import { removeSCSSTypeDefinitionFile } from "./remove-file.js";
+import { writeFile } from "./write-file.js";
+/**
+ * Watch a file glob and generate the corresponding types.
+ *
+ * @param pattern the file pattern to watch for file changes or additions
+ * @param options the CLI options
+ */
+export const watch = (pattern, options) => {
+    listFilesAndPerformSanityChecks(pattern, options);
+    alerts.success("Watching files...");
+    const watcher = chok.watch(pattern, {
+        ignoreInitial: options.ignoreInitial,
+        ignored: options.ignore,
+    });
+    watcher
+        .on("change", (path) => {
+        alerts.info(`[CHANGED] ${path}`);
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        writeFile(path, options);
+    })
+        .on("add", (path) => {
+        alerts.info(`[ADDED] ${path}`);
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        writeFile(path, options);
+    })
+        .on("unlink", (path) => {
+        alerts.info(`[REMOVED] ${path}`);
+        removeSCSSTypeDefinitionFile(path, options);
+    });
+};

package/dist/lib/core/write-file.d.ts

@@ -0,0 +1,8 @@
+import type { CLIOptions } from "./types.js";
+/**
+ * Given a single file generate the proper types.
+ *
+ * @param file the SCSS file to generate types for
+ * @param options the CLI options
+ */
+export declare const writeFile: (file: string, options: CLIOptions) => Promise<void>;

package/dist/lib/core/write-file.js

@@ -0,0 +1,62 @@
+import fs from "fs";
+import path from "path";
+import { fileToClassNames } from "../sass/file-to-class-names.js";
+import { classNamesToTypeDefinitions, getTypeDefinitionPath, } from "../typescript/index.js";
+import { alerts } from "./alerts.js";
+import { removeSCSSTypeDefinitionFile } from "./remove-file.js";
+/**
+ * Given a single file generate the proper types.
+ *
+ * @param file the SCSS file to generate types for
+ * @param options the CLI options
+ */
+export const writeFile = async (file, options) => {
+    try {
+        const classNames = await fileToClassNames(file, options);
+        const typeDefinition = await classNamesToTypeDefinitions({
+            classNames,
+            file,
+            ...options,
+        });
+        const typesPath = getTypeDefinitionPath(file, options);
+        const typesExist = fs.existsSync(typesPath);
+        // Avoid outputting empty type definition files.
+        // If the file exists and the type definition is now empty, remove the file.
+        if (!typeDefinition) {
+            if (typesExist) {
+                removeSCSSTypeDefinitionFile(file, options);
+            }
+            else {
+                alerts.notice(`[NO GENERATED TYPES] ${file}`);
+            }
+            return;
+        }
+        // Avoid re-writing the file if it hasn't changed.
+        // First by checking the file modification time, then
+        // by comparing the file contents.
+        if (options.updateStaleOnly && typesExist) {
+            const fileModified = fs.statSync(file).mtime;
+            const typeDefinitionModified = fs.statSync(typesPath).mtime;
+            if (fileModified < typeDefinitionModified) {
+                return;
+            }
+            const existingTypeDefinition = fs.readFileSync(typesPath, "utf8");
+            if (existingTypeDefinition === typeDefinition) {
+                return;
+            }
+        }
+        // Files can be written to arbitrary directories and need to
+        // be nested to match the project structure so it's possible
+        // there are multiple directories that need to be created.
+        const dirname = path.dirname(typesPath);
+        if (!fs.existsSync(dirname)) {
+            fs.mkdirSync(dirname, { recursive: true });
+        }
+        fs.writeFileSync(typesPath, typeDefinition);
+        alerts.success(`[GENERATED TYPES] ${typesPath}`);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        alerts.error(`Write File '${file}' error: ${errorMessage}`);
+    }
+};

package/dist/lib/implementations/compilers.d.ts

@@ -0,0 +1,14 @@
+import type { AsyncCompiler, Implementation, Implementations, SyncCompiler } from "./implementations.js";
+export declare const disposeAllCompilers: () => Promise<void>;
+type ImplementationDetails = {
+    implementation: Implementations;
+    root: Implementation;
+};
+export declare const getSyncCompiler: ({ root, implementation, }: ImplementationDetails) => SyncCompiler | Pick<Implementation, "compile">;
+/**
+ * When calling the compile functions multiple times, using a compiler instance with the sass-embedded npm package
+ * is much faster than using the top-level compilation methods or the sass npm package.
+ * @see https://sass-lang.com/documentation/js-api/functions/initasynccompiler/
+ */
+export declare const getAsyncCompiler: ({ root, implementation, }: ImplementationDetails) => Promise<AsyncCompiler | Pick<Implementation, "compileAsync">>;
+export {};

package/dist/lib/implementations/compilers.js

@@ -0,0 +1,49 @@
+import { alerts } from "../core/index.js";
+const cache = {};
+export const disposeAllCompilers = async () => {
+    // Cleanup of any cached compilers
+    cache.syncCompiler?.dispose();
+    cache.syncCompiler = undefined;
+    if (cache.asyncCompiler) {
+        const asyncCompiler = await cache.asyncCompiler;
+        await asyncCompiler?.dispose();
+        cache.asyncCompiler = undefined;
+    }
+};
+process.on("SIGINT", async () => {
+    await disposeAllCompilers();
+    process.exit(0);
+});
+export const getSyncCompiler = ({ root, implementation, }) => {
+    /* When calling the compile functions multiple times, using a compiler instance with the sass-embedded npm package
+    is much faster than using the top-level compilation methods or the sass npm package */
+    const useCompilerInstance = implementation === "sass-embedded";
+    if (!useCompilerInstance) {
+        return root;
+    }
+    if (cache.syncCompiler) {
+        return cache.syncCompiler;
+    }
+    cache.syncCompiler = root.initCompiler();
+    alerts.info(`Using '${implementation}' Sync compiler instance for improved performance.`);
+    return cache.syncCompiler;
+};
+/**
+ * When calling the compile functions multiple times, using a compiler instance with the sass-embedded npm package
+ * is much faster than using the top-level compilation methods or the sass npm package.
+ * @see https://sass-lang.com/documentation/js-api/functions/initasynccompiler/
+ */
+export const getAsyncCompiler = ({ root, implementation, }) => {
+    /* When calling the compile functions multiple times, using a compiler instance with the sass-embedded npm package
+    is much faster than using the top-level compilation methods or the sass npm package */
+    const useCompilerInstance = implementation === "sass-embedded";
+    if (!useCompilerInstance) {
+        return Promise.resolve(root);
+    }
+    if (cache.asyncCompiler) {
+        return cache.asyncCompiler;
+    }
+    cache.asyncCompiler = root.initAsyncCompiler();
+    alerts.info(`Using '${implementation}' Async compiler instance for improved performance.`);
+    return cache.asyncCompiler;
+};

package/dist/lib/implementations/implementations.d.ts

@@ -0,0 +1,27 @@
+import sass, { AsyncCompiler as SassAsyncCompiler, Compiler as SassCompiler } from "sass";
+import sassEmbedded, { AsyncCompiler as SassEmbeddedAsyncCompiler, Compiler as SassEmbeddedCompiler } from "sass-embedded";
+/**
+ * A list of all possible SASS package implementations that can be used to
+ * perform the compilation and parsing of the SASS files. The expectation is
+ * that they provide a nearly identical API so they can be swapped out but
+ * all of the same logic can be reused.
+ */
+export declare const IMPLEMENTATIONS: readonly ["sass", "sass-embedded"];
+export type Implementations = (typeof IMPLEMENTATIONS)[number];
+export type Implementation = typeof sass | typeof sassEmbedded;
+export type SyncCompiler = SassCompiler | SassEmbeddedCompiler;
+export type AsyncCompiler = SassAsyncCompiler | SassEmbeddedAsyncCompiler;
+/**
+ * Determine which default implementation to use by checking which packages
+ * are actually installed and available to use.
+ *
+ * @param resolver DO NOT USE - this is unfortunately necessary only for testing.
+ */
+export declare const getDefaultImplementation: (resolver?: RequireResolve) => Implementations;
+/**
+ * Retrieve the desired implementation.
+ *
+ * @param implementation the desired implementation.
+ */
+export declare const getImplementation: (implementation?: Implementations | string) => Promise<Implementation>;
+export declare const getImplementationAsync: (implementation?: Implementations | string) => Promise<Implementation>;

package/dist/lib/implementations/implementations.js

@@ -0,0 +1,54 @@
+import sass, { AsyncCompiler as SassAsyncCompiler, Compiler as SassCompiler, } from "sass";
+import sassEmbedded, { AsyncCompiler as SassEmbeddedAsyncCompiler, Compiler as SassEmbeddedCompiler, } from "sass-embedded";
+/**
+ * A list of all possible SASS package implementations that can be used to
+ * perform the compilation and parsing of the SASS files. The expectation is
+ * that they provide a nearly identical API so they can be swapped out but
+ * all of the same logic can be reused.
+ */
+export const IMPLEMENTATIONS = ["sass", "sass-embedded"];
+/**
+ * Determine which default implementation to use by checking which packages
+ * are actually installed and available to use.
+ *
+ * @param resolver DO NOT USE - this is unfortunately necessary only for testing.
+ */
+export const getDefaultImplementation = (resolver) => {
+    let pkg = "sass";
+    try {
+        resolver ? resolver("sass") : import("sass");
+    }
+    catch (error) {
+        try {
+            resolver ? resolver("sass-embedded") : import("sass-embedded");
+            pkg = "sass-embedded";
+        }
+        catch (ignoreError) {
+            pkg = "sass";
+        }
+    }
+    return pkg;
+};
+/**
+ * Retrieve the desired implementation.
+ *
+ * @param implementation the desired implementation.
+ */
+export const getImplementation = async (
+// eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+implementation = "sass") => {
+    return getImplementationAsync(implementation);
+};
+export const getImplementationAsync = (
+// eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+implementation = "sass") => {
+    if (implementation === "sass") {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        return import("sass");
+    }
+    if (implementation === "sass-embedded") {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        return import("sass-embedded");
+    }
+    throw new Error(`'${implementation}' Implementation is not supported`);
+};

package/dist/lib/implementations/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./compilers.js";
+export * from "./implementations.js";

package/dist/lib/implementations/index.js

@@ -0,0 +1,2 @@
+export * from "./compilers.js";
+export * from "./implementations.js";

package/dist/lib/index.d.ts

@@ -0,0 +1,3 @@
+export type { ConfigOptions } from "./core/types.js";
+export { IMPLEMENTATIONS, type Implementations, } from "./implementations/implementations.js";
+export { main as default } from "./main.js";

package/dist/lib/index.js

@@ -0,0 +1,2 @@
+export { IMPLEMENTATIONS, } from "./implementations/implementations.js";
+export { main as default } from "./main.js";

package/dist/lib/load.d.ts

@@ -0,0 +1,20 @@
+import { type CLIOptions, type ConfigOptions } from "./core/types.js";
+/**
+ * Load a custom config file in the project root directory with any options for this package.
+ *
+ * This supports config files in the following formats and order:
+ *  - Named `config` export: `export const config = {}`
+ *  - Default export: `export default {}`
+ *  - `module.exports = {}`
+ */
+export declare const loadConfig: () => Promise<Record<string, never> | ConfigOptions>;
+export declare const DEFAULT_OPTIONS: CLIOptions;
+/**
+ * Given both the CLI and config file options merge into a single options object.
+ *
+ * When possible, CLI options will override config file options.
+ *
+ * Some options are only available in the config file. For example, a custom function can't
+ * be easily defined via the CLI so some complex options are only available in the config file.
+ */
+export declare const mergeOptions: (cliOptions: Partial<CLIOptions>, configOptions: Partial<ConfigOptions>) => ConfigOptions;

package/dist/lib/load.js

@@ -0,0 +1,87 @@
+import { bundleRequire } from "bundle-require";
+import JoyCon from "joycon";
+import path from "path";
+import { alerts } from "./core/alerts.js";
+import {} from "./core/types.js";
+import { getDefaultImplementation } from "./implementations/implementations.js";
+import { nameFormatDefault } from "./sass/file-to-class-names.js";
+import { bannerTypeDefault, exportTypeDefault, exportTypeInterfaceDefault, exportTypeNameDefault, logLevelDefault, quoteTypeDefault, } from "./typescript/index.js";
+const VALID_CONFIG_FILES = [
+    "typed-scss-modules.config.ts",
+    "typed-scss-modules.config.mjs",
+    "typed-scss-modules.config.js",
+];
+const joycon = new JoyCon.default();
+/**
+ * Load a custom config file in the project root directory with any options for this package.
+ *
+ * This supports config files in the following formats and order:
+ *  - Named `config` export: `export const config = {}`
+ *  - Default export: `export default {}`
+ *  - `module.exports = {}`
+ */
+export const loadConfig = async () => {
+    const CURRENT_WORKING_DIRECTORY = process.cwd();
+    const configPath = await joycon.resolve(VALID_CONFIG_FILES, CURRENT_WORKING_DIRECTORY, path.parse(CURRENT_WORKING_DIRECTORY).root);
+    if (configPath) {
+        try {
+            const configModule = await bundleRequire({
+                filepath: configPath,
+            });
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            const config = 
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            configModule.mod.config || configModule.mod.default || configModule.mod;
+            return config;
+        }
+        catch (error) {
+            alerts.error(
+            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+            `An error occurred loading the config file "${configPath}":\n${error}`);
+            return {};
+        }
+    }
+    return {};
+};
+// Default values for all options that need defaults.
+export const DEFAULT_OPTIONS = {
+    nameFormat: [nameFormatDefault],
+    implementation: getDefaultImplementation(),
+    exportType: exportTypeDefault,
+    exportTypeName: exportTypeNameDefault,
+    exportTypeInterface: exportTypeInterfaceDefault,
+    watch: false,
+    ignoreInitial: false,
+    listDifferent: false,
+    ignore: [],
+    quoteType: quoteTypeDefault,
+    updateStaleOnly: false,
+    logLevel: logLevelDefault,
+    banner: bannerTypeDefault,
+    outputFolder: null,
+    allowArbitraryExtensions: false,
+    silenceDeprecations: ["legacy-js-api"],
+};
+const removedUndefinedValues = (obj) => {
+    for (const key in obj) {
+        if (obj[key] === undefined) {
+            delete obj[key];
+        }
+    }
+    return obj;
+};
+/**
+ * Given both the CLI and config file options merge into a single options object.
+ *
+ * When possible, CLI options will override config file options.
+ *
+ * Some options are only available in the config file. For example, a custom function can't
+ * be easily defined via the CLI so some complex options are only available in the config file.
+ */
+export const mergeOptions = (cliOptions, configOptions) => {
+    return {
+        ...DEFAULT_OPTIONS,
+        ...configOptions,
+        ...removedUndefinedValues(cliOptions),
+    };
+};

package/dist/lib/main.d.ts

@@ -0,0 +1,2 @@
+import { type CLIOptions } from "./core/index.js";
+export declare const main: (pattern: string, cliOptions: Partial<CLIOptions>) => Promise<void>;

package/dist/lib/main.js

@@ -0,0 +1,34 @@
+import fs from "fs";
+import path from "path";
+import slash from "slash";
+import { generate, listDifferent, setAlertsLogLevel, watch, } from "./core/index.js";
+import { disposeAllCompilers } from "./implementations/compilers.js";
+import { loadConfig, mergeOptions } from "./load.js";
+export const main = async (pattern, cliOptions) => {
+    const configOptions = await loadConfig();
+    const options = mergeOptions(cliOptions, configOptions);
+    setAlertsLogLevel(options.logLevel);
+    // When the provided pattern is a directory construct the proper glob to find
+    // all .scss files within that directory. Also, add the directory to the
+    // included paths so any imported with a path relative to the root of the
+    // project still works as expected without adding many include paths.
+    if (fs.existsSync(pattern) && fs.lstatSync(pattern).isDirectory()) {
+        if (Array.isArray(options.loadPaths)) {
+            options.loadPaths.push(pattern);
+        }
+        else {
+            options.loadPaths = [pattern];
+        }
+        // When the pattern provide is a directory, assume all .scss files within.
+        pattern = slash(path.resolve(pattern, "**/*.scss"));
+    }
+    if (options.listDifferent) {
+        await listDifferent(pattern, options);
+        return;
+    }
+    if (options.watch) {
+        watch(pattern, options);
+        return;
+    }
+    await generate(pattern, options).finally(() => disposeAllCompilers());
+};

package/dist/lib/prettier/can-resolve.d.ts

@@ -0,0 +1 @@
+export declare function canResolvePrettier(): boolean;

package/dist/lib/prettier/can-resolve.js

@@ -0,0 +1,12 @@
+// this is only extracted to a module to mock in testing as require.resolve can't be mocked.
+// https://github.com/facebook/jest/issues/9543
+export function canResolvePrettier() {
+    try {
+        import("prettier");
+        return true;
+    }
+    catch (_error) {
+        // cannot resolve prettier
+        return false;
+    }
+}

package/dist/lib/prettier/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Try to load prettier and config from project to format input,
+ * fall back to input if prettier is not found or failed
+ *
+ * @param {file} file
+ * @param {string} input
+ */
+export declare const attemptPrettier: (file: string, input: string) => Promise<string>;