@maka/maka-cli 5.1.23 → 5.1.25

package/bundle/typescript/src/tools/scaffold/scaffold.class.d.ts

@@ -0,0 +1,197 @@
+import { FSI } from '../fsi/fsi.class.js';
+import { MPI } from '../mpi/mpi.class.js';
+import { IPath, ITemplatePath, ICopyTemplateDir, IInjectIntoFile, IProjectConfig, InjectImportParams } from '../fsi/fsi.interfaces';
+export declare class Scaffold {
+    private static instance;
+    private fsi;
+    private mpi;
+    private constructor();
+    static getInstance(fsi: FSI, mpi: MPI): Scaffold;
+    createEmptyMeteorProject(name: any, opts: any): Promise<void>;
+    /**
+     * Returns an object with the type and engine given a srcPath.
+     * For example, given foo.bar.baz, returns { type: 'bar', engine: 'baz' }
+     */
+    engineAndTypeFromfilePath({ filePath }: {
+        filePath: any;
+    }): {
+        type: any;
+        engine: any;
+    };
+    /**
+     * Given a path of ./foo.bar.baz of the schema ./foo.<type>.<engine>, rewrite
+     * the destination path to only use the type extension. For example,
+     *
+     * foo.css.less would be rewritten to be foo.css
+     */
+    rewriteDestinationPathForType({ pathParts, config }: IPath): string;
+    /**
+     * Given a source file with a name that follows this schema:
+     *
+     * <template-name>.<type>[.engine]
+     *
+     * Iff there is an engine defined, make sure this template file is the right one
+     * for the given engine. If there is no engine defined, assume the file is okay
+     * and return true.
+     */
+    isTemplateForEngine({ pathParts, config }: IPath): boolean;
+    /**
+     * Like the function above, but doesn't change the name of the extension.
+     */
+    writeSourcePath({ pathParts }: IPath): string;
+    /**
+     * Given a path of ./foo.bar.baz of the schema ./foo.<type>.<engine>, rewrite
+     * the destination path to only use the engine extension. For example,
+     *
+     * foo.css.less would be rewritten to be foo.less.
+     */
+    rewriteDestinationPathForEngine({ pathParts, config }: IPath): string;
+    /**
+     * If we have a srcPath of foo/bar.js and an engine for js that maps to typescript,
+     * then rewrite the path to foo/bar.js.ts.
+     *
+     * The schema for templates looks like this:
+     *
+     * <template-name>.<type>[.<engine>]
+     *
+     * You should omit the engine in the template file name if it's the same as the
+     * type. So instead of mytemplate.js.js you would just create mytemplate.js and
+     * it's assumed that the engine is js.
+     *
+     * The path paramter to this function is automatically adjusted to look for the
+     * template file for the configured engine. For example, if your js engine is
+     * 'typescript' then a src path of '/path/to/template.js' will be translated to
+     * '/path/to/template.js.ts'.
+     *
+     */
+    rewriteSourcePathForEngine({ pathParts, framework, config }: IPath): string;
+    /**
+     * Returns a path relative to lib/templates, with the source path
+     * rewritten to use the appropriate engine. See the rewriteSourcePathForEngine
+     * method above.
+     */
+    pathFromTemplates({ pathParts, framework, config }: IPath): string;
+    /**
+     * Returns a compiled template from srcPath using the ejs templating.
+     * A data context can be passed as the last parameter. This function
+     * lets us get a compiled template result without writing to a file. It
+     * can be useful when you want to inject some template content into an
+     * existing file, for example.
+     */
+    templateContent({ srcPath, context, framework, config }: {
+        srcPath: any;
+        context: any;
+        framework: any;
+        config: any;
+    }): string;
+    /**
+     * Compile and write an ejs template from the srcPath to the destPath. The
+     * destPath is rewritten for the given engine. For example, if your js
+     * engine is 'coffee' then '/path/to/dest.js' will be rewritten to
+     * 'path/to/dest.coffee'
+     */
+    template({ srcPath, destPath, context, config, framework, force, ignore }: ITemplatePath): Promise<void>;
+    /**
+     * Recursively copies a template directory (from the lib/templates directory) to
+     * the dest path following these rules:
+     *
+     *  1.  All folders in the srcPath are copied to destPath, building the folder
+     *      hierarchy as needed.
+     *  2.  Files matching the current engines (e.g. html/jade, js/coffee,
+     *      css/scss/less) are copied. Files not matching any current engines are
+     *      ignored.
+     *  3.  All files are compiled through ejs with the data context optionally
+     *      provided as a last parameter.
+     *  4.  ignore accepts an array of strings which will match files with relative
+     *      paths to the app folder to ignore.
+     */
+    copyTemplateDirectory({ srcPath, destPath, context, ignore, keep, framework, config }: ICopyTemplateDir): Promise<void>;
+    /**
+     * Inject content at the top of a file. If the file
+     * doesn't exist yet, create it.
+     */
+    injectAtBeginningOfFile({ filePath, content, opts }: IInjectIntoFile): Promise<void>;
+    /**
+     * Inject content at the end of the file. If the file
+     * doesn't exist yet, create it. If the content already exists,
+     * do not inject it again.
+     */
+    injectAtEndOfFile({ filePath, content, opts }: IInjectIntoFile): Promise<void>;
+    /**
+     * Inject content around a specified target string or strings in a file, matching and adjusting the file's indentation,
+     * but only if the content is not already present. Allows separate adjustment of the target line's indentation.
+     */
+    injectAroundString({ filePath, aboveContent, belowContent, targetString, indentAdjustment, targetIndentAdjustment }: {
+        filePath: any;
+        aboveContent: any;
+        belowContent: any;
+        targetString: any;
+        indentAdjustment?: number | undefined;
+        targetIndentAdjustment?: number | undefined;
+    }): Promise<void>;
+    /**
+     * Adjusts the detected indentation by the specified amount.
+     */
+    private adjustIndentation;
+    /**
+     * Detects the most common indentation in the file.
+     */
+    private detectIndentation;
+    /**
+     * Finds the most common number of indent characters of a given type in the lines.
+     */
+    private getCommonIndentSize;
+    /**
+     * Calculates the mode (most frequent value) in an array.
+     */
+    private calculateMode;
+    /**
+     * Inject content into a specific section of a file, defined by start pattern(s), but only if the content doesn't already exist.
+     */
+    injectIntoCodeBlock({ filePath, content, begin, replace }: {
+        filePath: any;
+        content: any;
+        begin: any;
+        replace?: boolean | undefined;
+    }): Promise<void>;
+    /**
+     * Inject content at the end of the section which begins with the 'begin'
+     * parameter and ends with 'end' parameter. The begin and end parameters
+     * should be regular expressions.
+     */
+    injectIntoFile({ filePath, content, begin, end, replace }: {
+        filePath: any;
+        content: any;
+        begin: any;
+        end: any;
+        replace?: boolean | undefined;
+    }): Promise<void>;
+    /**
+     * Inject content at the end of the section which begins with the 'begin'
+     * parameter and ends with 'end' parameter. The begin and end parameters
+  
+    /**
+     * Injects a new import at the specified position of all the imports in a JS file.
+     */
+    injectImport({ filePath, importName, modulePath, isNamedExport, injectAtStart }: InjectImportParams): Promise<void>;
+    injectTemplateModule(resourceName: string, projectConfig: IProjectConfig, modulePath: string): Promise<void>;
+    /**
+     * Inject a string into a file after a line number.
+     */
+    injectAfterLineNumber({ filePath, content, lineNumber }: {
+        filePath: any;
+        content: any;
+        lineNumber: any;
+    }): void;
+    /**
+     * Returns the absolute path to the given filePath relative to the app
+     * directory (e.g. my-project/app/filePath). If no app directory is
+     * found the function returns false. Rewrites the source path to use
+     * the appropriate engine. See the rewriteSourcePathForEngine method above.
+     */
+    pathFromApp({ pathParts, config }: IPath): string;
+    /**
+     * Just like above, but doesn't rewrite the extension.
+     */
+    pathFromAppWithNoReWrite({ pathParts, config }: IPath): string;
+}