@hanseltime/template-repo-sync 1.0.1

package/.eslintrc.js

@@ -0,0 +1,10 @@
+module.exports = {
+  env: {
+    node: true,
+  },
+  ignorePatterns: ["lib/**/*"],
+  extends: ["eslint:recommended", "plugin:@typescript-eslint/recommended"],
+  parser: "@typescript-eslint/parser",
+  plugins: ["@typescript-eslint"],
+  root: true,
+};

package/.github/CODEOWNERS

@@ -0,0 +1,6 @@
+# This is a comment.
+# Each line is a file pattern followed by one or more owners.
+
+# These owners will be the default owners for everything in
+# the repo, Unless a later match takes precedence.
+*       @hanseltime

package/.github/workflows/pr-checks.yaml

@@ -0,0 +1,12 @@
+name: PR Checks
+run-name: ${{ github.head_ref }} PR Checks
+
+on:
+  pull_request:
+    branches: [main, alpha]
+
+jobs:
+  call-test-workflow:
+    uses: ./.github/workflows/test-flow.yaml
+    with:
+      from: ${{ github.workflow }}

package/.github/workflows/release.yaml

@@ -0,0 +1,36 @@
+name: Release
+run-name: ${{ github.ref_name }} Release
+
+on:
+  push:
+    branches:
+      - main
+      - alpha
+
+jobs:
+  call-test-workflow:
+    uses: ./.github/workflows/test-flow.yaml
+    with:
+      from: ${{ github.workflow }}
+  release:
+    runs-on: ubuntu-latest
+    needs: call-test-workflow
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          token: ${{ secrets.RELEASE_PAT }}
+      - name: Use Node.js 20.x
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20.x
+          cache: "npm"
+          cache-dependency-path: package-lock.json
+      - name: Install
+        run: npm ci
+      - name: Build
+        run: npm run build
+      - name: Release
+        run: npm run release
+        env:
+          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+          GITHUB_TOKEN: ${{ secrets.RELEASE_PAT }}

package/.github/workflows/test-flow.yaml

@@ -0,0 +1,58 @@
+name: Tests
+on:
+  workflow_call:
+    inputs:
+      from:
+        required: true
+        type: string
+
+# This will cancel in progress jobs if another job with the same ref gets started.
+# Github run_id is a backup in case github.ref doesn't exist for some reason
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref || github.run_id }}
+  cancel-in-progress: true
+
+jobs:
+  ci-checks:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [18.x, 20.x]
+
+    steps:
+      - uses: actions/checkout@v3
+      # TODO: caching this action would accelerate the run
+      - name: corepack
+        run: |
+          corepack enable
+      - uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node-version }}
+          cache: "npm"
+          cache-dependency-path: package-lock.json
+      - name: install
+        run: |
+          npm ci
+      - name: commit-linting
+        run: |
+          if [[ "${{ github.base_ref }}" != "" ]]; then
+            echo "Setting up git environment for commitlint of pull request"
+            git fetch origin ${{ github.base_ref }}
+            git fetch origin ${{ github.head_ref }}
+            npx commitlint --from ${{ github.event.pull_request.head.sha }}~${{ github.event.pull_request.commits }} --to ${{ github.event.pull_request.head.sha }} --verbose
+          else
+            echo "Setting up git environment for commitlint of branch push"
+            git fetch origin ${{ github.ref_name }} --unshallow
+            npx commitlint --from $(git rev-list --max-parents=0 origin/${{ github.ref_name }})
+          fi
+      - name: build
+        run: |
+          npm run build
+      - name: linting
+        run: |
+          npm run lint
+          npx prettier . --check
+      - name: testing
+        run: |
+          npm run test

package/.husky/commit-msg

@@ -0,0 +1,4 @@
+#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+npx commitlint --edit $1

package/.prettierignore

@@ -0,0 +1 @@
+CHANGELOG.md

package/.prettierrc

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

package/CHANGELOG.md

@@ -0,0 +1,27 @@
+## [1.0.1](https://github.com/HanseltimeIndustries/template-repo-sync/compare/v1.0.0...v1.0.1) (2024-03-03)
+
+
+### Bug Fixes
+
+* adding despcription ([4ef4e57](https://github.com/HanseltimeIndustries/template-repo-sync/commit/4ef4e57ef824e19d363839482d6664b61b670804))
+
+# 1.0.0 (2024-03-03)
+
+
+### Bug Fixes
+
+* adding json spacing inference for writes ([fb28695](https://github.com/HanseltimeIndustries/template-repo-sync/commit/fb2869585b23adbaeb4d50a9eeaf9345b4130b20))
+* creating directory if missing ([ff53e90](https://github.com/HanseltimeIndustries/template-repo-sync/commit/ff53e90c5b03e46082dff7a1c910a52b379fd569))
+* do not merge .git ([a18799e](https://github.com/HanseltimeIndustries/template-repo-sync/commit/a18799e90ef95352d171018605f97d1abbb2fccc))
+* pushing upstream ([c127b15](https://github.com/HanseltimeIndustries/template-repo-sync/commit/c127b15012d19ba821df61020acb3c784334f000))
+* removing gha concern for separate package ([963bdf8](https://github.com/HanseltimeIndustries/template-repo-sync/commit/963bdf88659386aab99dc95258f1e7ca84fc098b))
+* slight adjustment to formatting ([bea1519](https://github.com/HanseltimeIndustries/template-repo-sync/commit/bea151916dcc519da91ad75db9cc5d56a6897f5d))
+* updating how template sync returns ([0ef0f73](https://github.com/HanseltimeIndustries/template-repo-sync/commit/0ef0f7331bc45d72001244560579671600fc4195))
+* updating valdiation for linting ([b3f39e5](https://github.com/HanseltimeIndustries/template-repo-sync/commit/b3f39e595e6866e284a99d9a1259e96d4f45730a))
+
+
+### Features
+
+* adding afterRef support ([66f16e7](https://github.com/HanseltimeIndustries/template-repo-sync/commit/66f16e7057a5129d9255b684a08fdda31211209a))
+* initializing jsonpath support in two different repos ([a1438a2](https://github.com/HanseltimeIndustries/template-repo-sync/commit/a1438a22a5bd39ad70dde600ab2b9ba8a7e99972))
+* setting up the github action flow ([5ef6772](https://github.com/HanseltimeIndustries/template-repo-sync/commit/5ef67728f29e8f266f81cdf84c6d75d2aa9441d0))

package/README.md

@@ -0,0 +1,93 @@
+# Template Sync Action
+
+This npm package seeks to provide further granularity for people hoping to maintain a base template repo in github that
+is either imported or used as a literal template repo.
+
+In both of those cases, the downstream repos that have based themselves off of this template can quickly become out of sync for 2 reasons:
+
+1. The template repo is actively being developed with new standards
+2. The downstream repo has changes to support their use cases
+
+If we were to consider that the template and its downstream repos are part of say, an organization's attempt at standardizing their
+best practice development patterns, then we naturally want to have a way to allow each downstream implementer to adopt the newest
+changes, while also having control over things that may be specifically changed due to their need to support something beyond the
+orgnaization standard.
+
+# How to use this
+
+This repository publishes a github action that can be used for ease of use in github. It also provides itself as an npm package
+for those who would like to implement the same calls in another CI/CD structure.
+
+## Config file
+
+There are two types of config files that you can create:
+
+- `templatesync.config` in the template repo (this is for the template maintainer to specify how they would expect a roll out
+  to update and for them to exclude anything that is more of an example than a standard (for instance, a hellow world placeholder))
+
+- `templatesync.local.config` in the repo that cloned the template. This is meant for the repo maintainers to have the ability to avoid
+  or customize updates between the template repo in the event that they have deviated purposefully from it.
+
+This library will always respect the overrides of the local template sync file if it exists but, as a compromise to rapidly developing
+templates and their repos, will also provide a list of all files whose template sync behavior was either ignored or overridden by the local
+file. In this way, teams should be able to track (with a little extra CI/CD wiring) or at the very least, explicitly acknowledge a deviation.
+
+### File format
+
+```typescript
+export interface Config {
+  /**
+   * A set of micromatch globs that we are supposed to ignore
+   */
+  ignore: string[];
+  /**
+   * If there is no merge config, then we will always just overwrite the file for the diff
+   */
+  merge: {
+    /**
+     * .json file merge overrides.  Keep in mind,
+     */
+    ".json": {
+      // You can add a merge plugin for extensions that we don't natively support
+      mergePlugin: string;
+      /**
+       * A list of file globs for json files that can have custom rules applied
+       *
+       * The first matching glob will be applied so make sure to put your defaults last
+       */
+      [fileGlobs: string]: JsonFileMerge;
+    }[];
+  };
+}
+```
+
+### Example 1
+
+```typescript
+{
+
+    merge: {
+        ".ini": {
+            // If you are running under pacakge manager like yarn or npm,
+            // you can provide a valid pacakge or .js fil from your package to run
+            driver: 'my-installed-npm-package',
+        }
+    }
+}
+```
+
+## From SHA/Tag directive
+
+One of the biggest pains of syncing templates is that you can end up seeing a change multiple times because your change has
+purposefully desynchronized from the template. For instance, let's say that you need to support a newer framework than
+the template you cloned from. You have added a PR to the template to upgrade, but the template maintainers are worried about
+the effect of the change on all other template-based repos and are waiting. In the meantime, you still want to get any new
+security patterns or boilerplate patterns for other tools.
+
+To solve this, rudimentarily, we allow the local template sync config to provide a `afterRef` option. When provided, template sync
+will only apply changes that have occurred after the ref (tag or sha) in question in the git based repo. This does not mean
+that you will never see changes to the files from the last sync (because if someone changed something in that same file, all of its changes will be copied over),
+but it does mean that you will only see the changes to files that are newer than the last time you looked at it.
+
+As always, you can remove the SHA/Tag from your local config and this will trigger a full sync in the event that you made the wrong
+assumption about merging templates correctly.

package/action.yml

@@ -0,0 +1,13 @@
+name: "Template Repo Sync Action"
+description: "Action for taking the files in a template repo and synchronizing them to the repo via a PR"
+inputs:
+  who-to-greet: # id of input
+    description: "Who to greet"
+    required: true
+    default: "World"
+outputs:
+  time: # id of output
+    description: "The time we greeted you"
+runs:
+  using: "node20"
+  main: "index.js"

package/commitlint.config.js

@@ -0,0 +1,3 @@
+module.exports = {
+  extends: ["@commitlint/config-angular"],
+};

package/jest.config.js

@@ -0,0 +1,19 @@
+module.exports = {
+  preset: "ts-jest",
+  testEnvironment: "node",
+  roots: ["<rootDir>/src"],
+  transform: {
+    "\\.tsx?$": "ts-jest",
+    "\\.jsx?$": "babel-jest",
+  },
+  collectCoverage: true,
+  collectCoverageFrom: ["./src/**"],
+  coverageThreshold: {
+    global: {
+      branches: 80,
+      functions: 80,
+      // Lines can get skewed by bucket files
+      statements: 80,
+    },
+  },
+};

package/lib/cjs/clone-drivers/git-clone.d.ts

@@ -0,0 +1 @@
+export declare function gitClone(tmpDir: string, repoUrl: string): Promise<string>;

package/lib/cjs/clone-drivers/git-clone.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gitClone = void 0;
+const child_process_1 = require("child_process");
+const path_1 = require("path");
+const CLONE_DIR = "cloned_repo";
+async function gitClone(tmpDir, repoUrl) {
+    (0, child_process_1.execSync)(`git clone ${repoUrl} ${CLONE_DIR}`, {
+        cwd: tmpDir,
+        env: process.env,
+    });
+    return (0, path_1.resolve)(tmpDir, CLONE_DIR);
+}
+exports.gitClone = gitClone;

package/lib/cjs/clone-drivers/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./types";
+export * from "./git-clone";

package/lib/cjs/clone-drivers/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./git-clone"), exports);

package/lib/cjs/clone-drivers/types.d.ts

@@ -0,0 +1,5 @@
+/**
+ * A function that clones the template repo into the provided tmpDir
+ * and then returns the relative path within that directory to the template root
+ */
+export type TemplateCloneDriverFn = (tmpDir: string, repoUrl: string) => Promise<string>;

package/lib/cjs/clone-drivers/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cjs/diff-drivers/git-diff.d.ts

@@ -0,0 +1 @@
+export declare function gitDiff(gitDir: string, afterRef: string): Promise<string[]>;

package/lib/cjs/diff-drivers/git-diff.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gitDiff = void 0;
+const child_process_1 = require("child_process");
+async function gitDiff(gitDir, afterRef) {
+    const diffFilesStr = (0, child_process_1.execSync)(`git diff ${afterRef}.. --name-only`, {
+        cwd: gitDir,
+    })
+        .toString()
+        .trim();
+    return diffFilesStr.split("\n");
+}
+exports.gitDiff = gitDiff;

package/lib/cjs/diff-drivers/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./types";
+export * from "./git-diff";

package/lib/cjs/diff-drivers/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./git-diff"), exports);

package/lib/cjs/diff-drivers/types.d.ts

@@ -0,0 +1,5 @@
+/**
+ * A function that operates within the gitDir, and returns the list of file paths
+ * since the last sha
+ */
+export type TemplateDiffDriverFn = (gitDir: string, afterRef: string) => Promise<string[]>;

package/lib/cjs/diff-drivers/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cjs/formatting/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./sync-results-to-md";
+export * from "./infer-json-indent";

package/lib/cjs/formatting/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./sync-results-to-md"), exports);
+__exportStar(require("./infer-json-indent"), exports);

package/lib/cjs/formatting/infer-json-indent.d.ts

@@ -0,0 +1 @@
+export declare function inferJSONIndent(rawJSON: string): string;

package/lib/cjs/formatting/infer-json-indent.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inferJSONIndent = void 0;
+const spacingRegex = /[{[]\n?(?<spacing>\s+)["tf\d]/;
+function inferJSONIndent(rawJSON) {
+    const match = spacingRegex.exec(rawJSON);
+    if (!match?.groups?.spacing) {
+        // eslint-disable-next-line no-console
+        console.warn(`Could not find json indentation for json string: ${rawJSON.slice(40)} ... \nDefaulting to 4 spaces`);
+        // Four spaces
+        return "    ";
+    }
+    const spacing = match.groups.spacing;
+    // Handle the case where there were multiple newlines before a value
+    const lastNewLine = spacing.lastIndexOf("\n");
+    return match?.groups.spacing.slice(lastNewLine >= 0 ? lastNewLine + 1 : 0);
+}
+exports.inferJSONIndent = inferJSONIndent;

package/lib/cjs/formatting/sync-results-to-md.d.ts

@@ -0,0 +1,2 @@
+import { TemplateSyncReturn } from "../template-sync";
+export declare function syncResultsToMd(result: TemplateSyncReturn): string;

package/lib/cjs/formatting/sync-results-to-md.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncResultsToMd = void 0;
+const template_sync_1 = require("../template-sync");
+function syncResultsToMd(result) {
+    return `# ${template_sync_1.TEMPLATE_SYNC_LOCAL_CONFIG} 
+
+## Stopped the following files from syncing:
+
+${result.localSkipFiles.reduce((s, file) => {
+        return `${s}* ${file}\n`;
+    }, "")}
+
+## Changed the following files from what they would have synced:
+
+${Object.keys(result.localFileChanges).reduce((s, file) => {
+        return `${s}${file}
+\`\`\`diff
+${result.localFileChanges[file].reduce((diffS, change) => {
+            return `${diffS}\n${makeChangeIntoDiffLines(change)}`;
+        }, "")}
+\`\`\``;
+    }, "")}
+`;
+}
+exports.syncResultsToMd = syncResultsToMd;
+function makeChangeIntoDiffLines(change, nonchangeMax = 3) {
+    const operator = change.added ? "+" : change.removed ? "-" : "";
+    if (!operator &&
+        nonchangeMax > 0 &&
+        change.count &&
+        change.count > nonchangeMax) {
+        const lines = change.value.split("\n");
+        const partial = lines.slice(lines.length - nonchangeMax);
+        return `...\n${partial.join("\n")}\n`;
+    }
+    return change.value.split("\n").reduce((s, line) => {
+        return `${s}${operator}${line}\n`;
+    }, "");
+}

package/lib/cjs/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./types";
+export * from "./template-sync";
+export * from "./formatting";

package/lib/cjs/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./template-sync"), exports);
+__exportStar(require("./formatting"), exports);

package/lib/cjs/load-plugin.d.ts

@@ -0,0 +1,2 @@
+import { MergeConfig, MergePlugin } from "./types";
+export declare function loadPlugin<T>(mergeConfig: MergeConfig<T>, forExt: string, configDir: string): Promise<MergePlugin<T>>;

package/lib/cjs/load-plugin.js

@@ -0,0 +1,63 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadPlugin = void 0;
+const plugins_1 = require("./plugins");
+const fs_1 = require("fs");
+const path_1 = require("path");
+async function loadPlugin(mergeConfig, forExt, configDir) {
+    let handler;
+    if (mergeConfig.plugin) {
+        // First check if this is a loal .js file
+        const localPath = (0, path_1.resolve)(configDir, mergeConfig.plugin);
+        const importPath = (0, fs_1.existsSync)(localPath) ? localPath : mergeConfig.plugin;
+        try {
+            // Sad workaround for testing since dynamic import segfaults
+            if (process.env.JEST_WORKER_ID !== undefined) {
+                // eslint-disable-next-line @typescript-eslint/no-var-requires
+                handler = require(importPath);
+            }
+            else {
+                handler = (await Promise.resolve(`${importPath}`).then(s => __importStar(require(s))));
+            }
+            if (!handler.merge) {
+                handler = handler
+                    .default;
+            }
+        }
+        catch (err) {
+            console.error(err);
+            throw err;
+        }
+    }
+    else {
+        if (!plugins_1.defaultExtensionMap[forExt]) {
+            throw new Error(`No default merge function supplied for ${forExt}.  Cannot have mere config without custom plugin supplied.`);
+        }
+        handler = plugins_1.defaultExtensionMap[forExt];
+    }
+    return handler;
+}
+exports.loadPlugin = loadPlugin;

package/lib/cjs/match.d.ts

@@ -0,0 +1,10 @@
+export declare function invertMatchPatterns(patterns: string[]): string[];
+/**
+ * Gets all the files in the directory recursively while avoiding any micromatch patterns
+ * that would match for ignoring
+ *
+ * @param dir
+ * @param ignorePatterns
+ * @returns
+ */
+export declare function getAllFilesInDir(dir: string, ignorePatterns: string[]): string[];

package/lib/cjs/match.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllFilesInDir = exports.invertMatchPatterns = void 0;
+const fs_1 = require("fs");
+const micromatch_1 = require("micromatch");
+const path_1 = require("path");
+function invertMatchPatterns(patterns) {
+    return patterns.map((pattern) => {
+        if (pattern.startsWith("!")) {
+            return pattern.slice(1);
+        }
+        return `!${pattern}`;
+    });
+}
+exports.invertMatchPatterns = invertMatchPatterns;
+/**
+ * Gets all the files in the directory recursively while avoiding any micromatch patterns
+ * that would match for ignoring
+ *
+ * @param dir
+ * @param ignorePatterns
+ * @returns
+ */
+function getAllFilesInDir(dir, ignorePatterns) {
+    return recurseDirsForFiles(dir, ignorePatterns);
+}
+exports.getAllFilesInDir = getAllFilesInDir;
+function recurseDirsForFiles(dirpath, ignorePatterns, relativeRoot = "") {
+    return (0, fs_1.readdirSync)(dirpath, {
+        withFileTypes: true,
+    }).reduce((files, f) => {
+        const relPath = (0, path_1.join)(relativeRoot, f.name);
+        if ((0, micromatch_1.some)(relPath, ignorePatterns)) {
+            return files;
+        }
+        // Ensure we aren't ignoring these folders explicitly
+        if (f.isDirectory()) {
+            files.push(...recurseDirsForFiles((0, path_1.join)(dirpath, f.name), ignorePatterns, relPath));
+        }
+        else {
+            files.push(relPath);
+        }
+        return files;
+    }, []);
+}