@git.zone/tspublish 1.11.6 → 1.12.1

package/readme.md

@@ -1,309 +1,209 @@
-# @git.zone/tspublish 🚀
+# @git.zone/tspublish
 
-> **Effortlessly publish multiple TypeScript packages from your monorepo**
-
-[![npm version](https://img.shields.io/npm/v/@git.zone/tspublish.svg)](https://www.npmjs.com/package/@git.zone/tspublish)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-
-## 🌟 What is tspublish?
-
-`@git.zone/tspublish` is a powerful CLI tool and library for managing and publishing multiple TypeScript packages from a monorepo. It automates the tedious parts of package publishing — discovery, dependency resolution, building, version validation, and multi-registry publishing — while giving you full control over the process. Whether you're maintaining a suite of microservices, a component library, or any collection of related packages, tspublish makes your life dramatically easier.
+Prepare and publish independently installable TypeScript packages from one repository.
+Each component has its own dependency list and package metadata; components share
+the repository version. TsBuild owns compilation. A release coordinator can prepare
+all packages before packing, journaling and publishing any of them.
 
 ## Issue Reporting and Security
 
 For reporting bugs, issues, or security vulnerabilities, please visit [community.foss.global/](https://community.foss.global/). This is the central community hub for all issue reporting. Developers who sign and comply with our contribution agreement and go through identification can also get a [code.foss.global/](https://code.foss.global/) account to submit Pull Requests directly.
 
-### ✨ Key Features
-
-- 📦 **Automatic Package Discovery** — Scans your monorepo for publishable `ts*` directories
-- 🎨 **Beautiful CLI Output** — Color-coded logging with progress bars and status indicators
-- 🔍 **Version Collision Detection** — Prevents accidental overwrites by checking the registry first
-- 🏗️ **Build Integration** — Automatically compiles TypeScript before publishing via `@git.zone/tsbuild`
-- 🎯 **Smart Dependency Management** — Inherits dependency versions from your monorepo's `package.json`
-- 🌐 **Multi-Registry Support** — Publish to npm, GitHub Packages, Gitea, or private registries
-- 🔗 **Base Registry Inheritance** — Use `useBase` / `extendBase` to inherit registries from `.smartconfig.json`
-- ⚡ **CLI Binary Support** — Automatically generates `cli.js` wrappers for publishable CLI packages
-- 🧹 **Clean Builds** — Creates isolated `dist_publish_*` directories for each package
-
-## 📥 Installation
-
-```bash
-# Using pnpm (recommended)
-pnpm add -D @git.zone/tspublish
-
-# Global installation for CLI usage
-pnpm add -g @git.zone/tspublish
-```
-
-## 🚀 Quick Start
-
-### 1️⃣ Structure Your Monorepo
-
-Organize your packages using directories that start with `ts`:
-
-```
-my-awesome-monorepo/
-├── package.json            # Main monorepo package.json (version is inherited)
-├── tsconfig.json           # Shared TypeScript config
-├── .smartconfig.json       # Optional: base registry configuration
-├── ts_core/                # Core package
-│   ├── index.ts            # Entry point
-│   ├── readme.md           # Package-specific documentation
-│   └── tspublish.json      # Publishing configuration
-├── ts_utils/               # Utilities package
-│   ├── index.ts
-│   ├── readme.md
-│   └── tspublish.json
-└── ts_cli/                 # CLI package
-    ├── index.ts
-    ├── readme.md
-    └── tspublish.json
-```
-
-### 2️⃣ Configure Each Package
-
-Create a `tspublish.json` in each publishable directory:
-
-```json
-{
-  "name": "@myorg/core",
-  "order": 1,
-  "dependencies": [
-    "@push.rocks/smartpromise",
-    "@push.rocks/smartfile"
-  ],
-  "registries": [
-    "registry.npmjs.org:public"
-  ],
-  "bin": []
-}
-```
-
-#### Configuration Options
+## Install
 
-| Field | Type | Description |
-|-------|------|-------------|
-| `name` | `string` | The published package name (e.g., `@myorg/core`) |
-| `order` | `number` | Build order for interdependent packages (lower builds first) |
-| `dependencies` | `string[]` | Dependencies to include — versions are resolved from the monorepo's `package.json` |
-| `registries` | `string[]` | Target registries with access level (format: `"url:accessLevel"`) |
-| `bin` | `string[]` | CLI executable names (generates a `cli.js` wrapper automatically) |
-
-### 3️⃣ Publish
-
-```bash
-# From your monorepo root
-npx tspublish
+```sh
+pnpm install --save-dev @git.zone/tspublish @git.zone/tsbuild
 ```
 
-That's it! tspublish will discover all `ts*` directories containing `tspublish.json`, build them in order, validate versions against the registry, and publish.
-
-## 🎯 Advanced Usage
-
-### Registry Configuration
+## Repository structure
 
-TSPublish offers three approaches for configuring target registries:
+Keep the repository manifest private when it holds dependencies for the entire
+toolbox. Each named module becomes a separate public package with a filtered
+dependency manifest.
 
-#### 1. Explicit Registries
-
-Define specific registries directly in `tspublish.json`:
-
-```json
-{
-  "registries": [
-    "registry.npmjs.org:public",
-    "npm.pkg.github.com:private"
-  ]
-}
+```text
+package.json
+tsconfig.json
+license.md
+ts_core/
+  index.ts
+  readme.md
+  tspublish.json
+ts_adapter/
+  index.ts
+  readme.md
+  tspublish.json
 ```
 
-The format is `"registryUrl:accessLevel"` where `accessLevel` is `public` or `private`.
+The repository's `package.json` supplies the shared version and external dependency
+versions. Internal package dependencies use the exact shared version, even when an
+older published version appears in the root manifest. Unknown external dependencies
+fail validation instead of being assigned the repository version.
 
-#### 2. Use Base Configuration (`useBase`)
+Each package requires its own `readme.md`. The root license is copied into every
+prepared package. `license.md` is preferred; existing repositories using `license`
+remain supported.
 
-Inherit registries from your project's `.smartconfig.json` (managed by `@git.zone/cli`):
+## Module configuration
 
 ```json
 {
-  "registries": ["useBase"]
+  "name": "@example/adapter",
+  "order": 2,
+  "description": "Optional provider adapter for the example toolbox.",
+  "dependencies": ["@example/core", "external-sdk"],
+  "registries": ["useBase"],
+  "bin": [],
+  "engines": { "node": ">=24" },
+  "sideEffects": false,
+  "include": ["third-party-notices.md"]
 }
 ```
 
-This reads from `.smartconfig.json` at the key `@git.zone/cli.release.registries`.
-
-#### 3. Extend Base Configuration (`extendBase`)
-
-Start with base registries and add or remove specific ones:
+Supported fields:
+
+| Field | Meaning |
+| --- | --- |
+| `name` | Published npm package name. Unnamed descriptors remain available to TsBuild for ordering only. |
+| `order` | Ordering preference among modules whose dependencies are ready. Dependencies always precede consumers. |
+| `dependencies` | Required package names, resolved from sibling modules or root production dependencies. |
+| `optionalDependencies` | Optional dependency names, resolved by the same rules. |
+| `peerDependencies` | Explicit peer version ranges. |
+| `peerDependenciesMeta` | Optional-peer metadata. |
+| `description` | Package description; defaults to the root description. |
+| `engines` | Runtime requirements; defaults to the root engines. |
+| `sideEffects` | Standard package side-effect declaration. |
+| `folders` | Additional `ts_*` folders owned by this package. A folder may have only one owner. |
+| `exports` | Explicit subpath/conditional exports into the package's compiled folders. Defaults to typed root exports. |
+| `include` | Exact repository-relative asset files or directories, including applicable notices. No globs or component source/compiled folders; use `folders` to declare source ownership. |
+| `bin` | Executable names using the module's exported `runCli()` entrypoint. Wrappers are generated locally. |
+| `registries` | Destination intent for the standalone publisher; also returned to release coordinators for validation. |
+
+Root author, license, repository, homepage, bugs, keywords and funding metadata are
+preserved. The private repository flag, root scripts, unrelated dependencies and
+development dependencies are not copied into prepared packages.
+
+Legacy `main` and `types` fields are derived from the root export's `node`,
+`import`, `default`, and `types` conditions when available. They never point at
+an unrelated default entrypoint when root exports are customized.
+
+For a subpath, include the additional source folder and declare both runtime and
+type entrypoints:
 
 ```json
 {
-  "registries": [
-    "extendBase",
-    "custom-registry.example.com:public",
-    "-https://registry.npmjs.org"
-  ]
-}
-```
-
-The `-` prefix excludes a registry from the base configuration. All other entries (besides `extendBase`) are added.
-
-#### Empty Registries
-
-If `registries` is an empty array `[]`, the package will be built but **not published** — useful for internal-only packages that other packages depend on.
-
-### Build Order Management
-
-When packages depend on each other, use the `order` field to control build sequence:
-
-```jsonc
-// ts_core/tspublish.json — builds first
-{
-  "name": "@myorg/core",
+  "name": "@example/core",
   "order": 1,
   "dependencies": [],
   "registries": ["useBase"],
-  "bin": []
-}
-
-// ts_utils/tspublish.json — builds second, depends on core
-{
-  "name": "@myorg/utils",
-  "order": 2,
-  "dependencies": ["@myorg/core"],
-  "registries": ["useBase"],
-  "bin": []
+  "folders": ["ts_migration"],
+  "exports": {
+    ".": {
+      "types": "./dist_ts_core/index.d.ts",
+      "import": "./dist_ts_core/index.js"
+    },
+    "./migration": {
+      "types": "./dist_ts_migration/index.d.ts",
+      "import": "./dist_ts_migration/index.js"
+    }
+  }
 }
 ```
 
-### CLI Binary Packages
+## Imports and local development
 
-For packages that ship CLI tools, specify the binary names in the `bin` array:
+Import sibling components through their published package names and declare them
+in `dependencies`. Configure TypeScript paths to their source entrypoints within
+the same repository; GitZone's TypeScript formatter discovers these mappings from
+`tspublish.json`. This requires no workspace symlinks or local package dependencies.
 
-```json
-{
-  "name": "@myorg/cli",
-  "order": 3,
-  "dependencies": ["commander", "@myorg/core"],
-  "registries": ["registry.npmjs.org:public"],
-  "bin": ["my-cli", "my-tool"]
-}
+Run the normal repository build before preparation:
+
+```sh
+pnpm build
 ```
 
-TSPublish will:
-1. Fetch the standard `cli.js` template from the `@git.zone/cli` assets repository
-2. Adjust the import path to point to the correct `dist_*` folder
-3. Configure the `bin` field in the generated `package.json`
+Preparation requires the matching `dist_ts*` outputs and verifies every export
+target. It inspects literal imports in sources and declarations and rejects
+undeclared dependencies and relative imports outside the component. Computed
+runtime imports remain the responsibility of the module author. Built-in Node
+modules are allowed. Browser compatibility must still be tested by each component.
 
-### Programmatic Usage
+Source folders, compiled folders and explicit assets are copied separately for
+each package. Symlinks, credential files and local dependency directories are
+rejected. Preparation does not bundle dependency implementations.
+
+## Plan and prepare
 
 ```typescript
 import { TsPublish } from '@git.zone/tspublish';
 
 const publisher = new TsPublish();
+const plan = await publisher.plan(process.cwd());
+// plan.modules is in deterministic dependency order; order equals its array index.
 
-// Publish all discovered modules in the current directory
-await publisher.publish(process.cwd());
-
-// Or just discover modules without publishing
-const modules = await publisher.getModuleSubDirs('./my-monorepo');
-console.log(modules);
-// => { ts_core: { name: '@myorg/core', order: 1, ... }, ts_utils: { ... } }
+const packages = await publisher.prepare(
+  process.cwd(),
+  '/absolute/existing-parent/new-package-directory',
+);
+// Each result contains folder, folders, name, version, order, manifest,
+// include, licenseFile, registries and its prepared directory.
 ```
 
-## 🔧 How It Works
-
-```
-┌──────────────────────────────────────────────────────────┐
-│                   tspublish pipeline                     │
-├──────────────────────────────────────────────────────────┤
-│                                                          │
-│  1. 🔍 Discovery                                        │
-│     Scan for ts* directories containing tspublish.json   │
-│                                                          │
-│  2. 📋 Preparation                                      │
-│     Create dist_publish_* with generated package.json,   │
-│     tsconfig.json, source files, readme, and license     │
-│                                                          │
-│  3. 🔨 Build                                            │
-│     Run `tsbuild tsfolders` in the publish directory     │
-│                                                          │
-│  4. ✅ Validation                                       │
-│     Check npm registry — abort if version already exists │
-│                                                          │
-│  5. 🚀 Publish                                          │
-│     pnpm publish to each configured registry             │
-│                                                          │
-└──────────────────────────────────────────────────────────┘
-```
+`plan()` reads manifests and license availability without writes, builds or network
+calls. It rejects duplicate package names, dependency cycles, unknown external
+dependency versions, local dependency links and invalid package paths.
 
-For each discovered module, tspublish:
+`prepare()` plans again and materializes the already-built packages. The output
+directory must not exist; its parent must already exist at a canonical path. Output
+cannot be nested inside an input folder. Preparation removes its own incomplete
+output on failure and never overwrites a prior result. The caller owns successful
+prepared directories and their cleanup.
 
-1. **Discovers** all directories starting with `ts` that contain a `tspublish.json`
-2. **Resolves dependencies** from the monorepo's `package.json`, using the monorepo version for packages not found in `dependencies`
-3. **Creates an isolated publish directory** (`dist_publish_<folder>`) with a generated `package.json`, `tsconfig.json`, source code copy, readme, and license
-4. **Builds** the package using `pnpm run build` (which calls `tsbuild tsfolders`)
-5. **Validates** against the target registry — if the name+version already exists, it exits with an error
-6. **Publishes** to each configured registry via `pnpm publish`
+Neither method installs dependencies, fetches templates, contacts registries,
+publishes packages or terminates the process.
 
-## 📚 API Reference
-
-### TsPublish
-
-The main class that orchestrates the entire publishing pipeline.
-
-```typescript
-class TsPublish {
-  /** Publish all discovered modules in a monorepo directory */
-  async publish(monorepoDirPath: string): Promise<void>;
+The CLI exposes the same operations:
 
-  /** Discover and return all publishable modules with their tspublish.json configs */
-  async getModuleSubDirs(dirPath: string): Promise<Record<string, ITsPublishJson>>;
-}
+```sh
+pnpm exec tspublish plan
+pnpm exec tspublish prepare /absolute/existing-parent/new-package-directory
 ```
 
-### ITsPublishJson
-
-The configuration interface for each `tspublish.json` file:
+A release coordinator should validate every module's destination intent, prepare
+all modules, pack every package, record the complete immutable artifact set, and
+then publish in the returned dependency order. Publication recovery must reuse
+those retained tarballs rather than rebuilding or preparing again.
 
-```typescript
-interface ITsPublishJson {
-  name: string;           // Published package name
-  order: number;          // Build sequence (lower = earlier)
-  dependencies: string[]; // Dependencies to include from monorepo
-  registries: string[];   // Target registries ("url:accessLevel", "useBase", or "extendBase")
-  bin: string[];          // CLI binary names
-}
-```
+## Existing standalone publisher
 
-### GiteaAssets
+The existing `TsPublish.publish(repository)` API and no-argument CLI remain
+available. They build and publish modules sequentially and do not provide
+transaction recovery. Use the owning repository's approved release workflow.
 
-Utility class for fetching files from Gitea repositories (used internally for CLI template retrieval):
+The standalone publisher supports explicit `registry.npmjs.org:public` entries,
+`useBase`, and `extendBase` with optional `-URL` exclusions. Base settings come
+from `@git.zone/cli.release.targets.npm` in `.smartconfig.json`; the previous
+`release.registries` and `release.accessLevel` fields remain readable.
+An empty registry list means build without publishing.
 
-```typescript
-class GiteaAssets {
-  constructor(options: { giteaBaseUrl: string; token?: string });
+Standalone generated builds use the repository's declared TsBuild version rather
+than looking up a mutable latest version. The `GiteaAssets` helper remains
+available from its source module for existing integrations.
 
-  /** Fetch files from a Gitea repository directory */
-  async getFiles(owner: string, repo: string, directory: string, branch?: string): Promise<IRepoFile[]>;
+## Development
 
-  /** Get the standard cli.js entry file template */
-  async getBinCliEntryFile(): Promise<IRepoFile>;
-}
+```sh
+pnpm build
+pnpm test
+pnpm exec tsbuild check 'test/**/*'
 ```
 
-## 🐛 Troubleshooting
-
-| Problem | Solution |
-|---------|----------|
-| **"Package X already exists with version Y"** | Bump the version in your monorepo's `package.json` |
-| **No publish modules found** | Ensure directories start with `ts` and contain a valid `tspublish.json` |
-| **Build failures** | Check TypeScript errors — tspublish runs `tsbuild tsfolders` in the generated directory |
-| **useBase/extendBase error** | Ensure `.smartconfig.json` has registries at `@git.zone/cli.release.registries` |
-| **Missing dependency versions** | Add the dependency to your monorepo's `package.json` `dependencies` field |
+Packaging tests use disposable directories and do not publish anything.
 
 ## License and Legal Information
 
-This repository contains open-source code licensed under the MIT License. A copy of the license can be found in the [license](./license) file.
+This repository contains open-source code licensed under the MIT License. A copy of the license can be found in the [license.md](./license.md) file.
 
 **Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.
 

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@git.zone/tspublish',
-  version: '1.11.6',
+  version: '1.12.1',
   description: 'A tool to publish multiple, concise, and small packages from monorepos, specifically for TypeScript projects within a git environment.'
 }

package/ts/classes.packagepreparer.ts

@@ -0,0 +1,135 @@
+import * as plugins from './plugins.js';
+import { assertPackagePath } from './functions.packageplan.js';
+import type { ITsPublishModulePlan, ITsPublishPlan, ITsPublishPreparedModule, TTsPublishExport } from './interfaces/index.js';
+
+/** Prepares already built modules. It never builds, installs, contacts a registry or publishes. */
+export class PackagePreparer {
+  constructor(private readonly root: string) {}
+
+  public async prepare(plan: ITsPublishPlan, outputDirectory: string): Promise<ITsPublishPreparedModule[]> {
+    const root = await plugins.fs.realpath(this.root);
+    const output = plugins.path.resolve(outputDirectory);
+    if (output === root || root.startsWith(`${output}${plugins.path.sep}`)) {
+      throw new Error('Package preparation requires a separate output directory.');
+    }
+    for (const module of plan.modules) {
+      for (const input of [...module.folders.flatMap((folder) => [folder, `dist_${folder}`]), ...module.include]) {
+        const inputPath = plugins.path.join(root, input);
+        if (output === inputPath || output.startsWith(`${inputPath}${plugins.path.sep}`)) {
+          throw new Error('Package output cannot be nested inside a package input.');
+        }
+      }
+    }
+    // The caller owns the parent; refusing existing output prevents overwriting artifacts.
+    const parent = await plugins.fs.realpath(plugins.path.dirname(output));
+    if (parent !== plugins.path.dirname(output)) throw new Error('Package output parent must be canonical.');
+    await plugins.fs.mkdir(output, { mode: 0o700 });
+    const prepared: ITsPublishPreparedModule[] = [];
+    try {
+      for (const module of plan.modules) {
+        const directory = plugins.path.join(output, module.folder);
+        await plugins.fs.mkdir(directory, { mode: 0o700 });
+        for (const folder of module.folders) {
+          await this.copyTree(root, folder, directory, folder, module);
+          await this.copyTree(root, `dist_${folder}`, directory, `dist_${folder}`, module);
+        }
+        for (const path of module.include) await this.copyTree(root, path, directory, path, module);
+        await this.copyTree(root, `${module.folder}/readme.md`, directory, 'readme.md', module);
+        await this.copyTree(root, module.licenseFile, directory, module.licenseFile, module);
+        if (module.manifest.bin) {
+          await plugins.fs.writeFile(plugins.path.join(directory, 'cli.js'),
+            `#!/usr/bin/env node\nprocess.env.CLI_CALL = 'true';\nconst cli = await import(${JSON.stringify(`./dist_${module.folder}/index.js`)});\nawait cli.runCli();\n`,
+            { mode: 0o755, flag: 'wx' });
+        }
+        for (const value of Object.values(module.manifest.exports)) await this.assertExport(directory, value);
+        await plugins.fs.writeFile(plugins.path.join(directory, 'package.json'), `${JSON.stringify(module.manifest, null, 2)}\n`, { flag: 'wx' });
+        prepared.push({ ...module, directory });
+      }
+      return prepared;
+    } catch (error) {
+      await plugins.fs.rm(output, { recursive: true, force: true });
+      throw error;
+    }
+  }
+
+  private async assertExport(directory: string, value: TTsPublishExport): Promise<void> {
+    if (value === null) return;
+    if (typeof value === 'string') {
+      const target = await plugins.fs.lstat(plugins.path.join(directory, value));
+      if (!target.isFile() || target.isSymbolicLink()) throw new Error(`Missing regular export file: ${value}`);
+      return;
+    }
+    for (const child of Object.values(value)) await this.assertExport(directory, child);
+  }
+
+  private async copyTree(root: string, source: string, output: string, destination: string, module: ITsPublishModulePlan): Promise<void> {
+    assertPackagePath(source);
+    assertPackagePath(destination);
+    if (source.split('/').some((part) => ['node_modules', '.git', '.npmrc', '.env'].includes(part) || part.startsWith('.env.'))) {
+      throw new Error('Package contents cannot include credentials or local runtime directories.');
+    }
+    // Check every ancestor, including explicitly included nested paths.
+    const segments = source.split('/');
+    for (let index = 1; index <= segments.length; index++) {
+      const stat = await plugins.fs.lstat(plugins.path.join(root, ...segments.slice(0, index)));
+      if (stat.isSymbolicLink()) throw new Error(`Package input cannot be a symlink: ${source}`);
+    }
+    const input = plugins.path.join(root, source);
+    const target = plugins.path.join(output, destination);
+    const stat = await plugins.fs.lstat(input);
+    if (stat.isDirectory()) {
+      await plugins.fs.mkdir(target, { recursive: true });
+      const entries = (await plugins.fs.readdir(input)).sort();
+      for (const entry of entries) {
+        if (entry === 'tspublish.json') continue;
+        await this.copyTree(root, `${source}/${entry}`, output, `${destination}/${entry}`, module);
+      }
+    } else if (stat.isFile()) {
+      if (/\.(?:[cm]?js|[cm]?ts|tsx|jsx)$/.test(source)) {
+        this.assertImports(source, await plugins.fs.readFile(input, 'utf8'), module);
+      }
+      await plugins.fs.mkdir(plugins.path.dirname(target), { recursive: true });
+      await plugins.fs.copyFile(input, target, 1); // COPYFILE_EXCL: generated metadata cannot be overwritten.
+    } else {
+      throw new Error(`Package input must be a regular file or directory: ${source}`);
+    }
+  }
+
+  private assertImports(file: string, content: string, module: ITsPublishModulePlan): void {
+    const ts = plugins.typescript;
+    const source = ts.createSourceFile(file, content, ts.ScriptTarget.Latest, true);
+    const allowed = new Set([
+      module.name,
+      ...Object.keys(module.manifest.dependencies),
+      ...Object.keys(module.manifest.optionalDependencies ?? {}),
+      ...Object.keys(module.manifest.peerDependencies ?? {}),
+    ]);
+    const check = (specifier: string): void => {
+      if (plugins.isBuiltin(specifier)) return;
+      if (specifier.startsWith('.')) {
+        const target = plugins.path.posix.normalize(plugins.path.posix.join(plugins.path.posix.dirname(file), specifier));
+        if (!module.folders.some((folder) => target.startsWith(`${folder}/`) || target.startsWith(`dist_${folder}/`))
+          && !module.include.some((path) => target === path || target.startsWith(`${path}/`))) {
+          throw new Error(`${module.name}: cross-package relative import ${specifier} in ${file}; use the published package name.`);
+        }
+        return;
+      }
+      const name = specifier.startsWith('@') ? specifier.split('/').slice(0, 2).join('/') : specifier.split('/')[0];
+      if (!allowed.has(name)) throw new Error(`${module.name}: undeclared dependency ${specifier} in ${file}.`);
+    };
+    const visit = (node: plugins.typescript.Node): void => {
+      if ((ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) && node.moduleSpecifier && ts.isStringLiteralLike(node.moduleSpecifier)) {
+        check(node.moduleSpecifier.text);
+      } else if (ts.isImportTypeNode(node) && ts.isLiteralTypeNode(node.argument) && ts.isStringLiteralLike(node.argument.literal)) {
+        check(node.argument.literal.text);
+      } else if (ts.isExternalModuleReference(node) && node.expression && ts.isStringLiteralLike(node.expression)) {
+        check(node.expression.text);
+      } else if (ts.isCallExpression(node) && node.arguments.length && ts.isStringLiteralLike(node.arguments[0])
+        && (node.expression.kind === ts.SyntaxKind.ImportKeyword || (ts.isIdentifier(node.expression) && node.expression.text === 'require'))) {
+        check(node.arguments[0].text);
+      }
+      ts.forEachChild(node, visit);
+    };
+    visit(source);
+  }
+}