md-hopper 1.0.0-alpha

package/README.md

@@ -0,0 +1,20 @@
+<!-- MD_HOPPER: CONFIG: -->
+
+# MD HOPPER
+
+This Package Link md files in same repository.
+
+# Commands
+
+<!-- MD_HOPPER: LINK_NEXT_LINE:
+id: generate-command
+inline: true
+-->
+
+[generate][md_hopper:generate-command]
+
+<!-- MD_HOPPER: BEGIN_DEFINE_LINKS: -->
+
+[md_hopper:generate-command]: ./src/cli/commands/generate/README.md 'GENERATE COMMAND'
+
+<!-- MD_HOPPER: END_DEFINE_LINKS: -->

package/cli/commands/generate/README.md/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "@cilly/md-hopper-cli-commands-generate-README.md",
+  "types": "../../../../dist/cli/commands/generate/README.md.d.ts",
+  "main": "../../../../dist/cli/commands/generate/README.md.js",
+  "sideEffects": false
+}

package/cli/commands/generate/action/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "@cilly/md-hopper-cli-commands-generate-action",
+  "types": "../../../../dist/cli/commands/generate/action.d.ts",
+  "main": "../../../../dist/cli/commands/generate/action.js",
+  "sideEffects": false
+}

package/cli/commands/generate/command/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "@cilly/md-hopper-cli-commands-generate-command",
+  "types": "../../../../dist/cli/commands/generate/command.d.ts",
+  "main": "../../../../dist/cli/commands/generate/command.js",
+  "sideEffects": false
+}

package/cli/commands/help/action/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "@cilly/md-hopper-cli-commands-help-action",
+  "types": "../../../../dist/cli/commands/help/action.d.ts",
+  "main": "../../../../dist/cli/commands/help/action.js",
+  "sideEffects": false
+}

package/cli/commands/help/command/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "@cilly/md-hopper-cli-commands-help-command",
+  "types": "../../../../dist/cli/commands/help/command.d.ts",
+  "main": "../../../../dist/cli/commands/help/command.js",
+  "sideEffects": false
+}

package/cli/commands/index/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "@cilly/md-hopper-cli-commands-index",
+  "types": "../../../dist/cli/commands/index.d.ts",
+  "main": "../../../dist/cli/commands/index.js",
+  "sideEffects": false
+}

package/cli/index/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "@cilly/md-hopper-cli-index",
+  "types": "../../dist/cli/index.d.ts",
+  "main": "../../dist/cli/index.js",
+  "sideEffects": false
+}

package/dist/_internal/types/command.d.ts

@@ -0,0 +1,11 @@
+import { Options, DefaultOptions } from './options.js';
+import { Settings } from './settings.js';
+export type Action = (...args: any[]) => any;
+export interface BeforeFunction {
+    fn: Action;
+    args: any[];
+}
+export interface ActionArg<T extends DefaultOptions> {
+    options: Options<T>;
+    settings: Settings;
+}

package/dist/_internal/types/command.js

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

package/dist/_internal/types/md.d.ts

@@ -0,0 +1,48 @@
+export declare const PROPERTIES: {
+    CONFIG: string;
+    LINK_NEXT_LINE: string;
+    BEGIN_LINKS: string;
+    END_LINKS: string;
+    BEGIN_DEFINE_LINKS: string;
+    END_DEFINE_LINKS: string;
+    BEFORE_GENERATE_LINK: string;
+};
+export interface PathInfo {
+    id: string;
+    lock: boolean;
+    title: string;
+    path: string;
+    dir: string;
+    output: string;
+    outputPath: string;
+}
+export interface PathDepthClassify {
+    children: string[];
+    grandchildren: string[];
+    parallels: string[];
+}
+export interface Detail extends PathInfo, PathDepthClassify {
+}
+export interface LinkNextLineProperties {
+    id: string;
+    inline: true;
+}
+export interface EndLinksProperties {
+    all: boolean;
+    linked: boolean;
+    child: boolean;
+    grandChild: boolean;
+    parallel: boolean;
+}
+export declare const LINK_NAME_PREFIX = "md_hopper:";
+export declare const BEGIN_COMMENT = "<!--";
+export declare const END_COMMENT = "-->";
+export declare const PARAM_SEPARATOR = ":";
+export declare const MD_HOPPER_COMMENT_PREFIX = "MD_HOPPER";
+export declare const COMMENT_REG_EXP: RegExp;
+export declare const BRAKE_LINE_REG_EXP: RegExp;
+export declare const LINK_REG_EXP: RegExp;
+export declare const MD_HOPPER_COMMENT_PREFIX_REG_EXP: RegExp;
+export declare const MD_HOPPER_PARAMS_REG_EXP: RegExp;
+export declare const MD_HOPPER_CONTENT_REG_EXP: RegExp;
+export declare const MD_HOPPER_PROPERTY_REG_EXP: RegExp;

package/dist/_internal/types/md.js

@@ -0,0 +1,21 @@
+export const PROPERTIES = {
+    CONFIG: 'CONFIG',
+    LINK_NEXT_LINE: 'LINK_NEXT_LINE',
+    BEGIN_LINKS: 'BEGIN_LINKS',
+    END_LINKS: 'END_LINKS',
+    BEGIN_DEFINE_LINKS: 'BEGIN_DEFINE_LINKS',
+    END_DEFINE_LINKS: 'END_DEFINE_LINKS',
+    BEFORE_GENERATE_LINK: 'BEFORE_GENERATE_LINK',
+};
+export const LINK_NAME_PREFIX = 'md_hopper:';
+export const BEGIN_COMMENT = '<!--';
+export const END_COMMENT = '-->';
+export const PARAM_SEPARATOR = ':';
+export const MD_HOPPER_COMMENT_PREFIX = 'MD_HOPPER';
+export const COMMENT_REG_EXP = new RegExp(`${BEGIN_COMMENT}\\s*.*?${END_COMMENT}`, 'gs');
+export const BRAKE_LINE_REG_EXP = new RegExp(/\r?\n/, 'g');
+export const LINK_REG_EXP = new RegExp('^\\s*.*\\[(.+)][(|\\[](.+)[)|\\]].*');
+export const MD_HOPPER_COMMENT_PREFIX_REG_EXP = new RegExp(`${BEGIN_COMMENT}\\s*${MD_HOPPER_COMMENT_PREFIX}${PARAM_SEPARATOR}\\s*`);
+export const MD_HOPPER_PARAMS_REG_EXP = new RegExp(`^[^${PARAM_SEPARATOR}]+${PARAM_SEPARATOR}(.*?)${END_COMMENT}.*`, 's');
+export const MD_HOPPER_CONTENT_REG_EXP = new RegExp(`^[^${PARAM_SEPARATOR}]+${PARAM_SEPARATOR}.*${END_COMMENT}(.*)`, 's');
+export const MD_HOPPER_PROPERTY_REG_EXP = new RegExp(`^([^${PARAM_SEPARATOR}]+?)${PARAM_SEPARATOR}.*`, 's');

package/dist/_internal/types/options.d.ts

@@ -0,0 +1,15 @@
+export interface BundleOptions {
+    skipHidden?: boolean;
+    include?: string;
+    exclude?: string;
+    filenames?: string;
+    output?: string;
+    input?: string;
+}
+export interface HelpOptions {
+    [key: string]: any;
+}
+export interface DefaultOptions {
+    [key: string]: any;
+}
+export type Options<T extends DefaultOptions = DefaultOptions> = T;

package/dist/_internal/types/options.js

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

package/dist/_internal/types/process.d.ts

@@ -0,0 +1,5 @@
+export declare const ENVS: {
+    readonly PACKAGE_VERSION: "PACKAGE_VERSION";
+    readonly IS_DEBUG: "IS_DEBUG";
+};
+export type Env = (typeof ENVS)[keyof typeof ENVS];

package/dist/_internal/types/process.js

@@ -0,0 +1,4 @@
+export const ENVS = {
+    PACKAGE_VERSION: 'PACKAGE_VERSION',
+    IS_DEBUG: 'IS_DEBUG',
+};

package/dist/_internal/types/settings.d.ts

@@ -0,0 +1,8 @@
+export interface Settings {
+    ['skip-hidden']: boolean;
+    include: string[];
+    exclude: string[];
+    filenames: string[];
+    output: string;
+}
+export type RcSettings = Partial<Settings>;

package/dist/_internal/types/settings.js

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

package/dist/_internal/utils/command.d.ts

@@ -0,0 +1,18 @@
+import { Command as Program } from 'commander';
+import { Action, ActionArg } from '../types/command.js';
+import { DefaultOptions } from '../types/options.js';
+import { Settings } from '../types/settings.js';
+export declare class CommandClass<T extends DefaultOptions> {
+    program: Program;
+    private befores;
+    private args;
+    constructor(program: Program);
+    init(options: ActionArg<T>['options'], settings: Settings): Promise<this>;
+    command(command: string): this;
+    help(helpTxt: string): CommandClass<T>;
+    before(before: Action, ...args: any[]): CommandClass<T>;
+    description(description: string): CommandClass<T>;
+    option(...args: any[]): CommandClass<T>;
+    requiredOption(...args: any[]): CommandClass<T>;
+    action(action: Action): void;
+}

package/dist/_internal/utils/command.js

@@ -0,0 +1,55 @@
+import { getSettings } from './settings.js';
+export class CommandClass {
+    program;
+    befores = [];
+    args;
+    constructor(program) {
+        this.program = program;
+    }
+    async init(options, settings) {
+        this.args = {
+            options,
+            settings,
+        };
+        return this;
+    }
+    command(command) {
+        this.program = this.program.command(command).option('-d, --debug', 'turn on debugging', false);
+        return this;
+    }
+    help(helpTxt) {
+        this.program = this.program.on('--help', () => {
+            console.log();
+            console.log(helpTxt);
+        });
+        return this;
+    }
+    before(before, ...args) {
+        this.befores.push({ fn: before, args: args });
+        return this;
+    }
+    description(description) {
+        this.program = this.program.description(description);
+        return this;
+    }
+    option(...args) {
+        const flags = args.shift();
+        this.program = this.program.option(flags, ...args);
+        return this;
+    }
+    requiredOption(...args) {
+        const flags = args.shift();
+        this.program = this.program.requiredOption(flags, ...args);
+        return this;
+    }
+    action(action) {
+        this.program = this.program.action(async (...args) => {
+            const options = args[0];
+            await this.init(options, getSettings(options.input || ''));
+            for (const before of this.befores) {
+                await before.fn(options, ...before.args);
+            }
+            return action(this.args, ...args);
+        });
+    }
+}

package/dist/_internal/utils/configs.d.ts

@@ -0,0 +1,3 @@
+export declare const SETTING_FILE_NAME = "README.md";
+export declare const importLineRegExp: RegExp;
+export declare const indentRegExp: RegExp;

package/dist/_internal/utils/configs.js

@@ -0,0 +1,3 @@
+export const SETTING_FILE_NAME = 'README.md';
+export const importLineRegExp = new RegExp(/\s*\/\/\s*@import\s+(\S+).*/g);
+export const indentRegExp = new RegExp(/^(\s*).*/);

package/dist/_internal/utils/fs.d.ts

@@ -0,0 +1 @@
+export { getAllFiles } from 'my-gadgetry/fs';

package/dist/_internal/utils/fs.js

@@ -0,0 +1 @@
+export { getAllFiles } from 'my-gadgetry/fs';

package/dist/_internal/utils/log.d.ts

@@ -0,0 +1,4 @@
+export declare const success: (...args: any[]) => void;
+export declare const warn: (...args: any[]) => void;
+export declare const info: (...args: any[]) => void;
+export declare const error: (...args: any[]) => void;

package/dist/_internal/utils/log.js

@@ -0,0 +1,13 @@
+import chalk from 'chalk';
+export const success = (...args) => {
+    console.log(chalk.green(...args));
+};
+export const warn = (...args) => {
+    console.log(chalk.hex('#FFA500')(...args));
+};
+export const info = (...args) => {
+    console.log(chalk.blue(...args));
+};
+export const error = (...args) => {
+    console.log(chalk.red(...args));
+};

package/dist/_internal/utils/md.d.ts

@@ -0,0 +1,5 @@
+import { Detail } from '../types/md.js';
+export declare const getParam: (text: string, key: string) => string;
+export declare const getParams: (text: string, key: string) => RegExpMatchArray | "";
+export declare const getTitle: (text: string) => string;
+export declare const replace: (detail: Detail, details: Detail[]) => string;

package/dist/_internal/utils/md.js

@@ -0,0 +1,231 @@
+import { readFileSync } from 'fs';
+import { PROPERTIES, LINK_NAME_PREFIX, COMMENT_REG_EXP, PARAM_SEPARATOR, LINK_REG_EXP, MD_HOPPER_COMMENT_PREFIX, MD_HOPPER_COMMENT_PREFIX_REG_EXP, MD_HOPPER_PROPERTY_REG_EXP, MD_HOPPER_PARAMS_REG_EXP, BRAKE_LINE_REG_EXP, MD_HOPPER_CONTENT_REG_EXP, BEGIN_COMMENT, END_COMMENT, } from '../types/md.js';
+import { getRelative } from './path.js';
+import { isBoolean } from './type-check.js';
+export const getParam = (text, key) => {
+    const PREFIX = `${BEGIN_COMMENT}\\s*${MD_HOPPER_COMMENT_PREFIX}:\\s*${key}:`;
+    const reg = new RegExp(`${PREFIX}(.*?)${END_COMMENT}`, 's');
+    if (!reg.test(text)) {
+        return '';
+    }
+    return reg.exec(text)[1];
+};
+export const getParams = (text, key) => {
+    const PREFIX = `${BEGIN_COMMENT}\\s*${MD_HOPPER_COMMENT_PREFIX}:\\s*${key}:`;
+    const reg = new RegExp(`${PREFIX}(.*?)${END_COMMENT}`, 'gs');
+    if (!reg.test(text)) {
+        return '';
+    }
+    return text.match(reg);
+};
+const getRemovedCommentOut = (text) => text.replace(COMMENT_REG_EXP, '');
+const getFirstLine = (text) => {
+    const lines = text.split('\n').filter(line => line.trim().length);
+    return lines.length ? lines[0].trim() : '';
+};
+export const getTitle = (text) => {
+    const title = getParam(text, 'TITLE');
+    if (title) {
+        return title;
+    }
+    const md = getRemovedCommentOut(text);
+    return getParam(text, 'TITLE') || md.replace(/\r?\n?#+(.*?)\r?\n.*/s, '$1').trim() || getFirstLine(md);
+};
+const getLinkName = (id) => `${LINK_NAME_PREFIX}${id}`;
+const getLink = (id, title) => `[${title}][${getLinkName(id)}]`;
+const getLinksByDetails = (details) => details.map(d => getLink(d.id, d.title));
+const getDefineLink = (id, url, title) => `[${getLinkName(id)}]: ${url}${title ? ` '${title}'` : ''}`;
+const replaceToLink = (txt, inline, detail) => {
+    if (LINK_REG_EXP.test(txt)) {
+        const url = txt.replace(LINK_REG_EXP, '$2');
+        if (url === getLinkName(detail.id)) {
+            return txt;
+        }
+        return `[${txt.replace(LINK_REG_EXP, '$1')}][${getLinkName(detail.id)}]
+<!-- ${MD_HOPPER_COMMENT_PREFIX}${PARAM_SEPARATOR} ${PROPERTIES.BEFORE_GENERATE_LINK}${PARAM_SEPARATOR} -->
+<!-- ${txt} -->
+`;
+    }
+    if (inline) {
+        return `[${txt}][${getLinkName(detail.id)}]`;
+    }
+    else {
+        return `[${detail.title}][${getLinkName(detail.id)}]
+${txt}
+`;
+    }
+};
+const getLinkContent = (path, content, { id, inline }, details) => {
+    const data = details.find(d => d.path !== path && d.id === id);
+    if (!data) {
+        return content;
+    }
+    const splits = content.split('\n');
+    const lines = [];
+    let firstLine = false;
+    for (const split of splits) {
+        if (split.trim().length && !firstLine) {
+            firstLine = true;
+            lines.push(replaceToLink(split, inline, data));
+            continue;
+        }
+        lines.push(split);
+    }
+    return lines.join('\n');
+};
+const getSectionParams = (section) => {
+    const params = section.replace(MD_HOPPER_PARAMS_REG_EXP, '$1');
+    const splits = params
+        .split(BRAKE_LINE_REG_EXP)
+        .filter(p => p.trim().length);
+    return {
+        params: splits.reduce((acc, keyValueText) => {
+            const keyValue = keyValueText.split(PARAM_SEPARATOR).map(k => k.trim());
+            if (keyValue.length !== 2) {
+                return acc;
+            }
+            acc[keyValue[0]] = isBoolean(keyValue[1]) ? JSON.parse(keyValue[1]) : keyValue[1];
+            return acc;
+        }, {}),
+        content: section.replace(MD_HOPPER_CONTENT_REG_EXP, '$1'),
+    };
+};
+const getRelateDetails = (details, list) => details.filter(d => list.includes(d.path));
+const push = (list, stack = []) => {
+    for (const data of list) {
+        stack.push(data);
+    }
+};
+const getLinksByProperties = (detail, properties, details) => {
+    if (properties.all) {
+        return details.filter(d => d.path !== detail.path);
+    }
+    const links = [];
+    if (properties.parallel) {
+        push(getRelateDetails(details, detail.parallels), links);
+    }
+    if (properties.child) {
+        push(getRelateDetails(details, detail.children), links);
+    }
+    if (properties.grandChild) {
+        push(getRelateDetails(details, detail.grandchildren), links);
+    }
+    return links;
+};
+const getLinksContent = (properties, linksDetails, lineLinkDetails) => {
+    let list = linksDetails;
+    if (!properties.linked) {
+        list = linksDetails.filter(d => lineLinkDetails.every(lineLinkDetail => lineLinkDetail.path !== d.path));
+    }
+    return `\n${getLinksByDetails(list).join('\n')}\n`;
+};
+const rebaseCommentSection = (property, params) => {
+    if (!Object.keys(params).length) {
+        return `${property}: ${END_COMMENT}`;
+    }
+    return `${property}:\n${Object.entries(params)
+        .map(([key, value]) => `${key}: ${value}`)
+        .join('\n')}\n${END_COMMENT}`;
+};
+const getSectionByContent = (property, params, content) => {
+    return `${rebaseCommentSection(property, params)}${content}`;
+};
+const getValidate = (detail, sections, details) => {
+    let hasEndLinksSection = false;
+    let hasBeginDefineLinksSection = false;
+    let hasEndDefineLinksSection = false;
+    let linksDetails = [];
+    const lineLinksDetails = [];
+    for (const section of sections) {
+        const property = section.replace(MD_HOPPER_PROPERTY_REG_EXP, '$1');
+        switch (property) {
+            case PROPERTIES.LINK_NEXT_LINE: {
+                const { params } = getSectionParams(section);
+                const data = details.find(d => d.path !== detail.path && d.id === params.id);
+                if (data) {
+                    lineLinksDetails.push(data);
+                }
+                break;
+            }
+            case PROPERTIES.BEGIN_LINKS:
+                linksDetails = getLinksByProperties(detail, getSectionParams(section).params, details);
+                break;
+            case PROPERTIES.END_LINKS:
+                hasEndLinksSection = true;
+                break;
+            case PROPERTIES.BEGIN_DEFINE_LINKS:
+                hasBeginDefineLinksSection = true;
+                break;
+            case PROPERTIES.END_DEFINE_LINKS:
+                hasEndDefineLinksSection = true;
+                break;
+        }
+    }
+    return {
+        hasEndLinksSection,
+        hasBeginDefineLinksSection,
+        hasEndDefineLinksSection,
+        linksDetails,
+        lineLinksDetails,
+    };
+};
+const setDefineLinks = (currentDir, details, defineMap = {}) => {
+    for (const { id, title, outputPath } of details) {
+        let url = getRelative(currentDir, outputPath);
+        if (!/^\.*\//.test(url)) {
+            url = `./${url}`;
+        }
+        defineMap[outputPath] = getDefineLink(id, url, title);
+    }
+};
+const getDefineLinksContent = (dir, linksDetails, lineLinkDetails, hasEndDefineLinksSection) => {
+    const defineMap = {};
+    setDefineLinks(dir, linksDetails, defineMap);
+    setDefineLinks(dir, lineLinkDetails, defineMap);
+    let content = `\n${Object.values(defineMap).join('\n')}\n`;
+    if (!hasEndDefineLinksSection) {
+        content += `${BEGIN_COMMENT} ${MD_HOPPER_COMMENT_PREFIX}${PARAM_SEPARATOR} ${PROPERTIES.END_DEFINE_LINKS}${PARAM_SEPARATOR} ${END_COMMENT}\n`;
+    }
+    return content;
+};
+export const replace = (detail, details) => {
+    const md = readFileSync(detail.path, 'utf-8');
+    const _sections = md.split(MD_HOPPER_COMMENT_PREFIX_REG_EXP);
+    const sections = [];
+    let i = -1;
+    const { hasEndLinksSection, hasBeginDefineLinksSection, hasEndDefineLinksSection, linksDetails, lineLinksDetails } = getValidate(detail, _sections, details);
+    for (const _section of _sections) {
+        ++i;
+        if (i === 0) {
+            sections.push(_section);
+            continue;
+        }
+        const property = _section.replace(MD_HOPPER_PROPERTY_REG_EXP, '$1');
+        const { params, content: _content } = getSectionParams(_section);
+        let content = _content;
+        let section = _section;
+        switch (property) {
+            case PROPERTIES.LINK_NEXT_LINE:
+                content = getLinkContent(detail.path, _content, params, details);
+                section = getSectionByContent(property, params, content);
+                break;
+            case PROPERTIES.BEGIN_LINKS:
+                content = getLinksContent(params, linksDetails, lineLinksDetails);
+                section = getSectionByContent(property, params, content);
+                if (!hasEndLinksSection) {
+                    section += `\n${BEGIN_COMMENT} ${MD_HOPPER_COMMENT_PREFIX}${PARAM_SEPARATOR} ${PROPERTIES.END_LINKS}${PARAM_SEPARATOR} ${END_COMMENT}`;
+                }
+                break;
+            case PROPERTIES.BEGIN_DEFINE_LINKS:
+                section = getSectionByContent(property, params, getDefineLinksContent(detail.dir, linksDetails, lineLinksDetails, hasEndDefineLinksSection));
+                break;
+            default:
+                break;
+        }
+        sections.push(section);
+    }
+    if (!hasBeginDefineLinksSection) {
+        sections.push(getSectionByContent(PROPERTIES.BEGIN_DEFINE_LINKS, {}, getDefineLinksContent(detail.dir, linksDetails, lineLinksDetails, hasEndDefineLinksSection)));
+    }
+    return sections.join(`${BEGIN_COMMENT} ${MD_HOPPER_COMMENT_PREFIX}${PARAM_SEPARATOR} `);
+};

package/dist/_internal/utils/path-match.d.ts

@@ -0,0 +1 @@
+export declare const isMatch: (path: string, pattern: string) => boolean;

package/dist/_internal/utils/path-match.js

@@ -0,0 +1,2 @@
+import { minimatch } from 'minimatch';
+export const isMatch = (path, pattern) => minimatch(path, pattern);

package/dist/_internal/utils/path.d.ts

@@ -0,0 +1,14 @@
+export declare const getProjectRootPath: () => string;
+export declare const getFullPath: (...path: string[]) => string;
+export declare const getDir: (path: string) => string;
+export declare const DEPTH_TYPES: {
+    ancestor: string;
+    parent: string;
+    parallel: string;
+    child: string;
+    grandchild: string;
+    different: string;
+};
+export type DepthType = (typeof DEPTH_TYPES)[keyof typeof DEPTH_TYPES];
+export declare const getDepthType: (thisDir: string, isTypeFromThisDir: string) => DepthType;
+export declare const getRelative: (dir: string, path: string) => string;

package/dist/_internal/utils/path.js

@@ -0,0 +1,52 @@
+import { existsSync } from 'fs';
+import { join, parse, relative } from 'path';
+import { SETTING_FILE_NAME } from './configs.js';
+export const getProjectRootPath = () => {
+    let path = process.cwd();
+    if (!existsSync(join(path, SETTING_FILE_NAME))) {
+        for (const _ in process.cwd().split(/\//g)) {
+            path = join(path, '..');
+            if (existsSync(join(path, SETTING_FILE_NAME))) {
+                break;
+            }
+        }
+    }
+    return path;
+};
+export const getFullPath = (...path) => join(getProjectRootPath(), ...path);
+export const getDir = (path) => {
+    return parse(path).dir;
+};
+export const DEPTH_TYPES = {
+    ancestor: 'ancestor',
+    parent: 'parent',
+    parallel: 'parallel',
+    child: 'child',
+    grandchild: 'grandchild',
+    different: 'different',
+};
+export const getDepthType = (thisDir, isTypeFromThisDir) => {
+    if (thisDir === isTypeFromThisDir) {
+        return DEPTH_TYPES.parallel;
+    }
+    const thisDirSeparators = thisDir.split('/');
+    const isTypeFromThisDirSeparators = isTypeFromThisDir.split('/');
+    if (thisDir.startsWith(isTypeFromThisDir)) {
+        if (thisDirSeparators.length - isTypeFromThisDirSeparators.length === 1) {
+            return DEPTH_TYPES.child;
+        }
+        else {
+            return DEPTH_TYPES.grandchild;
+        }
+    }
+    else if (isTypeFromThisDir.startsWith(thisDir)) {
+        if (isTypeFromThisDirSeparators.length - thisDirSeparators.length === 1) {
+            return DEPTH_TYPES.parent;
+        }
+        else {
+            return DEPTH_TYPES.ancestor;
+        }
+    }
+    return DEPTH_TYPES.different;
+};
+export const getRelative = (dir, path) => relative(dir, path);

package/dist/_internal/utils/process.d.ts

@@ -0,0 +1,6 @@
+import { Env } from '../types/process.js';
+export * from '../types/process.js';
+export declare const args: string[];
+export declare const init: () => void;
+export declare const set: (env: Env, value: string | boolean | number) => void;
+export declare const get: (env: Env) => string | boolean;

package/dist/_internal/utils/process.js

@@ -0,0 +1,27 @@
+import { ENVS } from '../types/process.js';
+import pkg from '../../../package.json' assert { type: 'json' };
+export * from '../types/process.js';
+export const args = process.argv.slice(2);
+export const init = () => {
+    set(ENVS.PACKAGE_VERSION, pkg.version);
+    set(ENVS.IS_DEBUG, bool(process.env.DEBUG) || args.includes('--debug'));
+};
+const bool = (val) => {
+    if (val === true || val === 'true') {
+        return true;
+    }
+    return false;
+};
+export const set = (env, value) => {
+    process.env[env] = `${value}`;
+};
+export const get = (env) => {
+    const val = process.env[env];
+    if (val === 'true') {
+        return true;
+    }
+    if (val === 'false') {
+        return false;
+    }
+    return val || '';
+};

package/dist/_internal/utils/settings.d.ts

@@ -0,0 +1,5 @@
+import { Settings } from '../types/settings.js';
+export declare const DEFAULT_MD_FILE_NAME = "README.md";
+export declare const DEFAULT_SETTINGS: Settings;
+export declare const parse: (txt: string) => Settings;
+export declare const getSettings: (inputFilename: string) => Settings;

package/dist/_internal/utils/settings.js

@@ -0,0 +1,45 @@
+import { readFileSync } from 'fs';
+import { getParam } from './md.js';
+import { SETTING_FILE_NAME } from './configs.js';
+import { getProjectRootPath } from './path.js';
+const Booleans = ['skip-hidden'];
+const Strings = ['exclude', 'include', 'filenames'];
+export const DEFAULT_MD_FILE_NAME = 'README.md';
+export const DEFAULT_SETTINGS = Object.freeze({
+    'skip-hidden': true,
+    exclude: [],
+    include: [],
+    filenames: [DEFAULT_MD_FILE_NAME],
+    output: DEFAULT_MD_FILE_NAME,
+});
+export const parse = (txt) => {
+    const lines = txt.split('\n');
+    const settings = JSON.parse(JSON.stringify(DEFAULT_SETTINGS));
+    for (const line of lines) {
+        const keyValue = line.split(':');
+        if (keyValue.length !== 2) {
+            continue;
+        }
+        const key = keyValue[0].trim();
+        const value = keyValue[1].trim();
+        let val;
+        if (Booleans.includes(key)) {
+            val = JSON.parse(`${value}`);
+        }
+        else if (Strings.includes(key)) {
+            val = value.split(',');
+        }
+        else {
+            continue;
+        }
+        settings[key] = val;
+    }
+    return {
+        ...DEFAULT_SETTINGS,
+        ...settings,
+    };
+};
+export const getSettings = (inputFilename) => {
+    const readme = readFileSync(`${getProjectRootPath()}/${inputFilename || SETTING_FILE_NAME}`, 'utf-8');
+    return parse(getParam(readme, 'CONFIG'));
+};

package/dist/_internal/utils/type-check.d.ts

@@ -0,0 +1 @@
+export declare const isBoolean: (val: any, isAllowString?: boolean) => boolean;

package/dist/_internal/utils/type-check.js

@@ -0,0 +1,10 @@
+import { isBoolean as _isBoolean } from 'my-gadgetry/type-check';
+export const isBoolean = (val, isAllowString = true) => {
+    if (_isBoolean(val)) {
+        return true;
+    }
+    if (isAllowString) {
+        return val === 'true' || val === 'false';
+    }
+    return false;
+};

package/dist/cli/commands/generate/action.d.ts

@@ -0,0 +1,3 @@
+import { ActionArg } from '../../../_internal/types/command.js';
+import { BundleOptions } from '../../../_internal/types/options.js';
+export declare const action: (args: ActionArg<BundleOptions>) => Promise<void>;

package/dist/cli/commands/generate/action.js

@@ -0,0 +1,87 @@
+import { readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { getAllFiles } from '../../../_internal/utils/fs.js';
+import { getParam, getTitle, replace } from '../../../_internal/utils/md.js';
+import { getProjectRootPath } from '../../../_internal/utils/path.js';
+import { getDir, getDepthType, DEPTH_TYPES } from '../../../_internal/utils/path.js';
+const replacePath = (str) => str.replace(/\/{2,}/, '/');
+const splitComma = (str, alternative) => (str ? str.split(',') : null) || alternative;
+const mergeConfig = ({ options, settings }) => {
+    return {
+        'skip-hidden': typeof options.skipHidden === 'undefined' ? settings['skip-hidden'] : JSON.parse(`${options.skipHidden}`),
+        exclude: splitComma(options.exclude, settings.exclude),
+        include: splitComma(options.include, settings.include),
+        filenames: splitComma(options.filenames, settings.filenames),
+        output: options.output || settings.output,
+    };
+};
+const classify = (dataList) => {
+    return dataList.reduce((mds, data) => {
+        const classifyList = { children: [], grandchildren: [], parallels: [] };
+        for (const { dir, path } of dataList) {
+            if (data.path === path) {
+                continue;
+            }
+            switch (getDepthType(dir, data.dir)) {
+                case DEPTH_TYPES.parallel:
+                    classifyList.parallels.push(path);
+                    break;
+                case DEPTH_TYPES.child:
+                    classifyList.children.push(path);
+                    break;
+                case DEPTH_TYPES.grandchild:
+                    classifyList.grandchildren.push(path);
+                    break;
+            }
+        }
+        mds.push({
+            ...data,
+            ...classifyList,
+        });
+        return mds;
+    }, []);
+};
+const getPathDetails = (paths, config) => {
+    const list = [];
+    for (const path of paths) {
+        const md = readFileSync(path, 'utf-8');
+        const id = getParam(md, 'ID').trim();
+        const LOCK = getParam(md, 'LOCK').trim();
+        const lock = LOCK ? JSON.parse(LOCK) : false;
+        const dir = getDir(path);
+        const output = getParam(md, 'OUTPUT').trim() || config.output;
+        list.push({
+            id,
+            lock,
+            title: (getTitle(md) || id || path).trim(),
+            path,
+            dir,
+            output,
+            outputPath: join(dir, output),
+        });
+    }
+    return classify(list);
+};
+export const action = async (args) => {
+    const rootPath = getProjectRootPath();
+    const config = mergeConfig(args);
+    const skipHidden = config['skip-hidden'] ? ['**/.*/**/*', '**/.*'] : [];
+    const exclude = [
+        '**/node_modules/.*/*',
+        '**/node_modules/**/*',
+        ...skipHidden,
+        ...config.exclude.map(path => replacePath(`${rootPath}/${path}`)),
+    ];
+    const include = config.include.map(path => replacePath(`${rootPath}/${path}`));
+    const paths = getAllFiles(rootPath, [], { include, exclude }).filter(path => config.filenames.some(filename => path.endsWith(`/${filename}`)));
+    const pathDetails = getPathDetails(paths, config);
+    for (const pathDetail of pathDetails) {
+        if (pathDetail.lock) {
+            continue;
+        }
+        const content = replace(pathDetail, pathDetails);
+        const output = pathDetail.output || config.output;
+        const writePath = output ? join(pathDetail.dir, output) : pathDetail.path;
+        writeFileSync(writePath, content, 'utf-8');
+    }
+};

package/dist/cli/commands/generate/command.d.ts

@@ -0,0 +1,2 @@
+import { Command as Program } from 'commander';
+export declare const init: (program: Program) => void;

package/dist/cli/commands/generate/command.js

@@ -0,0 +1,21 @@
+import { CommandClass } from '../../../_internal/utils/command.js';
+import { action } from './action.js';
+const setAliases = (commandClass) => {
+    commandClass
+        .description('This command is used to exec target file.')
+        .option('-sh --skip-hidden <boolean>', 'skip read hidden dir, default: true')
+        .option('-incl, --include <strings>', 'include dirs, default: [] (all files)')
+        .option('-excl, --exclude <strings>', 'ignore dirs, default: node_modules only')
+        .option('-f, --filenames <strings>', 'filenames, default: README.md only')
+        .option('-o, --output <filename>', 'output filename. default: README.md (replace)')
+        .option('-i, --input <filename>', 'target root filename, default: README.md')
+        .action(options => {
+        return action(options);
+    });
+};
+const commands = ['generate', 'g'];
+export const init = (program) => {
+    for (const command of commands) {
+        setAliases(new CommandClass(program).command(command));
+    }
+};

package/dist/cli/commands/help/action.d.ts

@@ -0,0 +1,3 @@
+import { ActionArg } from '../../../_internal/types/command.js';
+import { HelpOptions } from '../../../_internal/types/options.js';
+export declare const action: (_: ActionArg<HelpOptions>) => Promise<void>;

package/dist/cli/commands/help/action.js

@@ -0,0 +1,26 @@
+import { platform } from 'node:process';
+import { info } from '../../../_internal/utils/log.js';
+import { get, ENVS } from '../../../_internal/utils/process.js';
+const ASCII_ART = `
+ 
+ _       _   __   _   _   _             ___  ___   _____
+| |     | | |  \\ | | | | / /           /   |/   | |  _  \\
+| |     | | |   \\| | | |/ /           / /|   /| | | | | |
+| |     | | | |\\   | | |\\ \\          / / |__/ | | | | | |
+| |___  | | | | \\  | | | \\ \\        / /       | | | |_| |
+|_____| |_| |_|  \\_| |_|  \\_\\      /_/        |_| |_____/
+
+`;
+const VERSIONS = `
+  Link MD: ${get(ENVS.PACKAGE_VERSION)}
+  Node: ${process.versions.node}
+  OS: ${platform} ${process.arch}
+  `;
+const show = () => {
+    info(ASCII_ART);
+    info(VERSIONS);
+};
+export const action = async (_) => {
+    show();
+    return;
+};

package/dist/cli/commands/help/command.d.ts

@@ -0,0 +1,2 @@
+import { Command as Program } from 'commander';
+export declare const init: (program: Program) => void;

package/dist/cli/commands/help/command.js

@@ -0,0 +1,13 @@
+import { CommandClass } from '../../../_internal/utils/command.js';
+import { action } from './action.js';
+const setAliases = (commandClass) => {
+    commandClass.description('This command is used to show help').action(options => {
+        return action(options);
+    });
+};
+const commands = ['help', 'h'];
+export const init = (program) => {
+    for (const command of commands) {
+        setAliases(new CommandClass(program).command(command));
+    }
+};

package/dist/cli/commands/index.d.ts

@@ -0,0 +1,2 @@
+import { Command as Program } from 'commander';
+export declare const init: (program: Program) => Promise<void>;

package/dist/cli/commands/index.js

@@ -0,0 +1,8 @@
+const initCommand = async (filename, program) => {
+    ;
+    (await import(`./${filename}/command.js`)).init(program);
+};
+export const init = async (program) => {
+    await initCommand('generate', program);
+    await initCommand('help', program);
+};

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/index.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import { program } from 'commander';
+import { error } from '../_internal/utils/log.js';
+import { get, ENVS, init } from '../_internal/utils/process.js';
+import { init as initCommands } from './commands/index.js';
+init();
+program.version(`${get(ENVS.PACKAGE_VERSION)}`);
+await initCommands(program);
+program.action((_, args) => {
+    const cmd = args[0];
+    error(`${cmd} is not a Link MD command`);
+    error('');
+    error(`${cmd} has been renamed, please run instead`);
+    console.log('exit');
+    process.exit(1);
+});
+program.parse(process.argv);

package/package.json

@@ -0,0 +1,100 @@
+{
+  "name": "md-hopper",
+  "version": "1.0.0-alpha",
+  "description": "",
+  "type": "module",
+  "bin": {
+    "md-hopper": "./dist/cli/index.js",
+    "mdhopper": "./dist/cli/index.js",
+    "mdhop": "./dist/cli/index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cilly-yllic/md-hopper.git"
+  },
+  "bugs": {
+    "url": "https://github.com/cilly-yllic/md-hopper/issues"
+  },
+  "homepage": "https://github.com/cilly-yllic/md-hopper#readme",
+  "scripts": {
+    "prepare": "husky",
+    "jest": "jest",
+    "lint": "eslint .",
+    "lint:fix": "npm run lint -- --fix",
+    "_prettier": "prettier .",
+    "prettier:write": "npm run _prettier -- --write",
+    "prettier": "npm run prettier:write",
+    "prettier:check": "npm run _prettier -- --check",
+    "clean": "rimraf ./dist ./cli",
+    "tsc": "tsc -p tsconfig.publish.json && tsc-alias -p tsconfig.publish.json",
+    "generate": "tsx --tsconfig ./tsconfig.zx.json ./tools/generate-alias.zx.ts",
+    "ci:update-version": "tsx --tsconfig ./tsconfig.zx.json ./tools/update-version.zx.ts",
+    "md:generate": "tsx --tsconfig ./tsconfig.zx.json ./tools/generate-md.ts",
+
+    "//--- test ---//": "",
+    "test": "run-s test:*",
+    "test:lint": "npm run lint",
+    "test:prettier": "npm run prettier:check",
+    "test:jest": "npm run jest",
+
+    "//--- build ---//": "",
+    "build": "run-s build:*",
+    "build:test": "npm run test",
+    "build:clean": "npm run clean",
+    "build:tsc": "npm run tsc",
+    "build:generate": "npm run generate",
+
+    "//--- publish ---//": "",
+    "publish:build": "run-s build:{clean,tsc,generate}"
+  },
+  "author": "",
+  "exports": {
+    "./package.json": "./package.json"
+  },
+  "engines": {
+    "node": ">=19.0.0"
+  },
+  "license": "ISC",
+  "dependencies": {
+    "@actions/core": "^1.10.1",
+    "@actions/exec": "^1.1.1",
+    "@actions/github": "^6.0.0",
+    "chalk": "^5.3.0",
+    "commander": "^12.0.0",
+    "minimatch": "^9.0.4",
+    "my-gadgetry": "^1.1.2",
+    "zx": "^8.1.0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.24.5",
+    "@babel/preset-env": "^7.24.5",
+    "@babel/preset-typescript": "^7.24.1",
+    "@eslint/js": "^8.57.0",
+    "@types/jest": "^29.5.12",
+    "@typescript-eslint/eslint-plugin": "^7.9.0",
+    "@typescript-eslint/parser": "^7.9.0",
+    "babel-jest": "^29.7.0",
+    "eslint": "^8.57.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-import-resolver-typescript": "^3.6.1",
+    "eslint-plugin-import": "^2.29.1",
+    "eslint-plugin-jest": "^28.5.0",
+    "eslint-plugin-unused-imports": "^3.2.0",
+    "fs-extra": "^11.2.0",
+    "husky": "^9.0.11",
+    "jest": "^29.7.0",
+    "lint-staged": "^15.2.2",
+    "npm-run-all2": "^6.2.0",
+    "prettier": "^3.2.5",
+    "ts-jest": "^29.1.2",
+    "ts-node": "^10.9.2",
+    "tsc-alias": "^1.8.10",
+    "tsx": "^4.10.4",
+    "typescript": "^5.4.5",
+    "typescript-eslint": "^7.9.0"
+  },
+  "files": [
+    "cli",
+    "dist"
+  ]
+}