1.9.1

changelog.md

@@ -1,5 +1,184 @@
 # Changelog
 
+## 2025-01-02 - 1.9.1 - fix(publishmodule)
+Fix incorrect CLI script path during publish module creation
+
+- Updated the `createBinCliSetup` method to correctly adjust the CLI script path.
+- Replaced path in base64-decoded CLI file content from './dist_ts/index.js' to './dist_<packageSubFolder>/index.js'.
+
+## 2025-01-02 - 1.9.0 - feat(core)
+Refactor gitea asset handling and module initialization
+
+- Introduced GiteaAssets class to handle gitea asset fetching.
+- Updated TsPublish and PublishModule classes to use GiteaAssets.
+- Fixed queryParams in getFiles method of GiteaAssets.
+
+## 2025-01-01 - 1.8.0 - feat(core)
+Added GiteaAssets class for managing files in Gitea repositories
+
+- Introduced GiteaAssets class to handle file retrieval from Gitea repositories.
+- Added tests for GiteaAssets implementation.
+- Updated plugins module to include smartrequest for HTTP requests.
+
+## 2024-11-05 - 1.7.7 - fix(core)
+Fix dependency resolution in package initialization
+
+- Corrected the resolution of dependencies from tspublish.json against monorepo's package.json.
+- Ensures unlisted dependencies in monorepo's package.json default to its version.
+
+## 2024-11-05 - 1.7.6 - fix(tspublish)
+Fix the logging of the number of found publish modules
+
+- Corrected the way the number of publish modules is logged by using Object.keys(publishModules).length instead of publishModules.length.
+
+## 2024-11-05 - 1.7.5 - fix(core)
+Fix issue with tspublish.json name validation in TsPublish class
+
+- Resolved incorrect JSON parsing and validation for 'name' property in tspublish.json in the TsPublish.publish method.
+- Removed redundant JSON parse from plugin.smartfile.fs.toStringSync in publish method.
+
+## 2024-11-05 - 1.7.4 - fix(classes.tspublish)
+Refactor getModuleSubDirs method to streamline name validation for publish modules
+
+- Moved the check for the presence of the 'name' field in tspublish.json from getModuleSubDirs to the publish method.
+- Added log warning and continue flow if 'name' is not found during the publish process.
+
+## 2024-11-05 - 1.7.3 - fix(TsPublish)
+Add validation for tspublish.json name field
+
+- Ensure that the tspublish.json file contains a valid name field before processing.
+- Log a warning message if the name is not found in tspublish.json.
+
+## 2024-11-05 - 1.7.2 - fix(project)
+Fixed minor formatting issues and improved code consistency.
+
+- Added missing semicolons for consistency
+- Improved indentation in various files for better readability
+- Corrected usage of newlines and whitespace across the codebase
+
+## 2024-11-05 - 1.7.1 - fix(core)
+Implement error handling for missing publish module directories
+
+- Improved logging for package publish steps
+- Enhanced CLI feedback messages during the publishing process
+- Restructured package.json to ensure proper dependencies are published
+
+## 2024-11-05 - 1.7.0 - feat(core)
+Enhanced tspublish with ordered compilation and updated dependencies
+
+- Added 'order' property to ITsPublishJson interface to ensure project compilation order.
+- Updated development dependencies: @git.zone/tsbuild, @git.zone/tsbundle, @git.zone/tsrun, and @types/node.
+
+## 2024-10-28 - 1.6.0 - feat(classes.publishmodule)
+Added copying of readme and license files to publish directory
+
+- Enhanced the createPublishModuleDir method in PublishModule class to copy the 'readme.md' and 'license' files to the publish directory.
+
+## 2024-10-28 - 1.5.5 - fix(core)
+Handled non-existent package in publish module to avoid errors
+
+- Added error handling in TsPublish for packages not yet existing in the registry.
+
+## 2024-10-28 - 1.5.4 - fix(core)
+Fix issues with path keys in tsconfig and logger setup in logging.ts.
+
+- Corrected the iteration over paths in the createTsconfigJson method of PublishModule.
+- Fixed logger setup by ensuring console is enabled in logging.ts.
+
+## 2024-10-28 - 1.5.3 - fix(core)
+Fix incorrect logging and directory preparation
+
+- Corrected logging to accurately report the number of detected publish modules.
+- Ensured the publish directory is emptied before creating package.json.
+
+## 2024-10-28 - 1.5.2 - fix(core)
+Add logging for found publish modules
+
+- Added console logging to display the count and list of discovered publish modules during the publish process.
+- Included a startup log message indicating the beginning of the tspublish process.
+
+## 2024-10-28 - 1.5.1 - fix(core)
+Fixes handling of undefined paths in tsconfig generation.
+
+- Added a null check for `paths` in the original tsconfig before modifying it.
+- Enhanced testing by adding a test case for creating a TsPublish instance.
+
+## 2024-10-28 - 1.5.0 - feat(classes.publishmodule)
+Add method to create and write tsconfig.json during publish module setup
+
+- Introduced createTsconfigJson method in PublishModule class to generate a tsconfig.json for each publishable module.
+- Modified createPublishModuleDir method to include writing of tsconfig.json file.
+
+## 2024-10-26 - 1.4.0 - feat(core)
+Refactor directory reading and module discovery for publishing process
+
+- Renamed 'readDirectory' method to 'getModuleSubDirs' for clarity in describing function purpose.
+- Enhanced 'getModuleSubDirs' to return module information including parsed 'tspublish.json' data for each module.
+- Introduced new 'interfaces' directory to define TypeScript interfaces like 'ITsPublishJson'.
+
+## 2024-10-23 - 1.3.3 - fix(core)
+Fix logging mechanism on existing package version check
+
+- Changed the error handling mechanism when a package with the same version already exists to use logger and process exit instead of throwing an error.
+
+## 2024-10-23 - 1.3.2 - fix(core)
+Corrected file patterns in dynamically created package.json files.
+
+- Fixed incorrect file pattern from 'ts_web/**/*' to 'ts_*/**/*' in package.json creation process to include all subdirectories starting with 'ts'.
+
+## 2024-10-23 - 1.3.1 - fix(classes.publishmodule)
+Fix template string in createPackageJson method for export path
+
+- Corrected the syntax for template string in the exports path of created package.json
+
+## 2024-10-21 - 1.3.0 - feat(core)
+Add support for multiple registries in the publish process
+
+- Updated the PublishModule class to handle multiple registries for publishing.
+- Refactored the handling of tspublish.json by incorporating it into the PublishModule options.
+- Implemented logic to parse registry access level and apply it during publication.
+
+## 2024-10-21 - 1.2.4 - fix(publishmodule)
+Fix syntax errors and improve formatting in classes.publishmodule.ts
+
+- Fixed missing semicolons in multiple locations for improved syntax correctness.
+- Improved the formatting for better code readability.
+- Added --no-git-checks flag to the pnpm publish command.
+
+## 2024-10-21 - 1.2.3 - fix(logs)
+Improve logging mechanism with structured logs for publish process
+
+- Enhanced log messages to provide more clarity during module publishing.
+- Ensured logging captures steps of publish and init process in TsPublish and PublishModule classes respectively.
+
+## 2024-10-21 - 1.2.3 - fix(classes.publishmodule)
+Add missing 'type: module' to dynamically generated package.json
+
+- Ensure that the 'type: module' field is included in each dynamically generated package.json file for consistent module handling.
+
+## 2024-10-21 - 1.2.3 - fix(classes.publishmodule)
+Add missing 'type: module' to dynamically generated package.json
+
+- Ensure that the 'type: module' field is included in each dynamically generated package.json file for consistent module handling.
+
+## 2024-10-21 - 1.2.2 - fix(publishmodule)
+Fix bug in package.json creation for publish module
+
+- Fixed an issue where `package.json` was not being written to the publish module directory.
+
+## 2024-10-21 - 1.2.1 - fix(package.json)
+Ensure bin field is properly restructured
+
+- Fixed the structure of the package.json to ensure the bin field is accurately set.
+
+## 2024-10-21 - 1.2.0 - feat(core)
+Enhance package publication workflow with dependency handling and CLI improvements.
+
+- Updated package description and keywords in package.json and npmextra.json.
+- Integrated dependency extraction from root package.json into sub-package tspublish.json during initialization.
+- Added build and publish script executions for each submodule.
+- Improved CLI documentation and usage guidance in readme.md.
+
 ## 2024-10-21 - 1.1.0 - feat(core)
 Add runCli function to execute TsPublish process
 

npmextra.json

@@ -5,10 +5,22 @@
       "githost": "code.foss.global",
       "gitscope": "git.zone",
       "gitrepo": "tspublish",
-      "description": "publish multiple, concise and small packages from monorepos",
+      "description": "A tool to publish multiple, concise, and small packages from monorepos, specifically for TypeScript projects within a git environment.",
       "npmPackagename": "@git.zone/tspublish",
       "license": "MIT",
-      "projectDomain": "git.zone"
+      "projectDomain": "git.zone",
+      "keywords": [
+        "typescript",
+        "monorepo",
+        "package",
+        "publish",
+        "npm",
+        "automation",
+        "git",
+        "modularity",
+        "module-management",
+        "developer-tools"
+      ]
     }
   },
   "npmci": {

package.json

@@ -1,8 +1,8 @@
 {
   "name": "@git.zone/tspublish",
-  "version": "1.1.0",
+  "version": "1.9.1",
   "private": false,
-  "description": "publish multiple, concise and small packages from monorepos",
+  "description": "A tool to publish multiple, concise, and small packages from monorepos, specifically for TypeScript projects within a git environment.",
   "main": "dist_ts/index.js",
   "typings": "dist_ts/index.d.ts",
   "type": "module",
@@ -13,13 +13,16 @@
     "build": "(tsbuild --web --allowimplicitany)",
     "buildDocs": "(tsdoc)"
   },
+  "bin": {
+    "tspublish": "./cli.js"
+  },
   "devDependencies": {
-    "@git.zone/tsbuild": "^2.1.25",
+    "@git.zone/tsbuild": "^2.1.85",
-    "@git.zone/tsbundle": "^2.0.5",
+    "@git.zone/tsbundle": "^2.1.0",
-    "@git.zone/tsrun": "^1.2.46",
+    "@git.zone/tsrun": "^1.3.3",
     "@git.zone/tstest": "^1.0.44",
     "@push.rocks/tapbundle": "^5.0.15",
-    "@types/node": "^22.7.6"
+    "@types/node": "^22.8.7"
   },
   "repository": {
     "type": "git",
@@ -46,9 +49,24 @@
   ],
   "dependencies": {
     "@push.rocks/smartcli": "^4.0.11",
+    "@push.rocks/smartdelay": "^3.0.5",
     "@push.rocks/smartfile": "^11.0.21",
     "@push.rocks/smartlog": "^3.0.7",
     "@push.rocks/smartnpm": "^2.0.4",
-    "@push.rocks/smartpath": "^5.0.18"
+    "@push.rocks/smartpath": "^5.0.18",
-  }
+    "@push.rocks/smartrequest": "^2.0.23",
+    "@push.rocks/smartshell": "^3.0.6"
+  },
+  "keywords": [
+    "typescript",
+    "monorepo",
+    "package",
+    "publish",
+    "npm",
+    "automation",
+    "git",
+    "modularity",
+    "module-management",
+    "developer-tools"
+  ]
 }

readme.md

@@ -2,6 +2,192 @@
 
 publish multiple, concise and small packages from monorepos
 
-## How to create the docs
+## Install
 
-To create docs run gitzone aidoc.
+To install `@git.zone/tspublish`, you can use npm. To use the latest stable version, run:
+
+```bash
+npm install @git.zone/tspublish
+```
+
+Alternatively, if you are using yarn, the equivalent command would be:
+
+```bash
+yarn add @git.zone/tspublish
+```
+
+These commands will add `@git.zone/tspublish` as a dependency in your `package.json` file and install the package into your `node_modules` directory.
+
+## Usage
+
+`@git.zone/tspublish` is designed to manage the publishing of multiple, small-scale packages within monorepos. The following sections will guide you through its usage, from setting up your environment to effectively publishing packages.
+
+### Getting Started with TypeScript and Module Setup
+
+`@git.zone/tspublish` works with monorepos that are organized using TypeScript. The package structure should follow a convention where each submodule intended for publishing is located in a directory prefixed with `ts`, for example, `tsModuleName`. Each submodule directory should contain a `tspublish.json` file to correctly configure the package to be published separately. This file is critical for the `tspublish` process to identify valid package directories and should also include necessary metadata for the package.
+
+Your monorepo structure might resemble:
+
+```
+my-monorepo/
+├── ts-package1/
+│   ├── src/
+│   ├── tspublish.json
+├── ts-package2/
+│   ├── src/
+│   ├── tspublish.json
+```
+
+### Configuring `tspublish.json`
+
+Each submodule must include a `tspublish.json` within its directory. This JSON file should include essential details for your publishable package, including its dependencies. Here's a basic example of what `tspublish.json` could look like:
+
+```json
+{
+  "name": "@myorg/ts-package1",
+  "dependencies": {
+    "some-dependency": "^1.0.0"
+  }
+}
+```
+
+### Running the CLI
+
+`@git.zone/tspublish` includes a CLI that simplifies the publishing process. Begin by importing the CLI runner in a script within your project:
+
+```typescript
+import { runCli } from '@git.zone/tspublish';
+
+runCli();
+```
+
+This function call orchestrates the publishing operation. It reads each directory prefixed with `ts`, looks for a `tspublish.json`, and creates an individual package based on the gathered data.
+
+### Core Features
+
+#### Publishing Modules
+
+The core functionality provided by `@git.zone/tspublish` involves processing directories to check for valid submodules that are ready to be published. This occurs via the `publish` method in `TsPublish` class. This method does the following:
+
+- **Reads all directories** within the specified monorepo path.
+- **Identifies directories** that start with `ts` and validates the presence of `tspublish.json`.
+- **Logs** information about found packages for user awareness and debugging.
+- **Checks for collisions** with existing versions on the npm registry to prevent overriding published versions.
+
+```typescript
+import { TsPublish } from '@git.zone/tspublish';
+
+const tspublish = new TsPublish();
+await tspublish.publish('/path/to/your/monorepo');
+```
+
+#### Package Initialization
+
+Once valid submodules are identified, the `init` method in the `PublishModule` class initializes the publish module. This includes:
+
+- Parsing `tspublish.json` for metadata.
+- Constructing full paths for necessary operations.
+- Verifying package existence to avoid duplication.
+
+```typescript
+import { PublishModule } from '@git.zone/tspublish';
+
+const publishModule = new PublishModule({
+  monoRepoDir: '/path/to/monorepo',
+  packageSubFolder: 'ts-package1',
+});
+
+await publishModule.init();
+```
+
+#### Creating `package.json`
+
+Part of the publishing process involves automatically creating a `package.json` tailored to each submodule. This dynamically generated JSON will incorporate dependencies from `tspublish.json` and associate them with the latest version of `tsbuild` from the registry:
+
+```typescript
+await publishModule.createPackageJson();
+```
+
+This creates a structured `package.json` which includes scripts to build your TypeScript files before publishing.
+
+#### Constructing Publish-ready Directory
+
+After all configurations are verified and the `package.json` is created, the submodule is ready to be published. This step involves setting up a `dist_publish_` directory specific to each module:
+
+```typescript
+await publishModule.createPublishModuleDir();
+```
+
+The above method ensures that each module's source files are copied and prepared under a dedicated directory meant for packaging and distribution.
+
+### Logging and Debugging
+
+The package includes a structured logging mechanism using `smartlog` which provides insights into the publishing process, helping in runtime debugging and status tracking of operations:
+
+```typescript
+import { logger } from '@git.zone/tspublish/logging';
+
+logger.log('info', 'Publishing process initialized');
+```
+
+This powerful logging helps in tracking the status of each step and understanding potential issues during the operations.
+
+### Testing with tapbundle
+
+To ensure that your publishing workflow is functioning correctly, you can utilize the test suite set up with `tapbundle`. This library facilitates behavior-driven testing for your monorepo. Below is a basic test setup to verify the import and initial function accessibility of `@git.zone/tspublish`:
+
+```typescript
+import { expect, tap } from '@push.rocks/tapbundle';
+import * as tspublish from '@git.zone/tspublish';
+
+tap.test('Should run the CLI without errors', async () => {
+  await tspublish.runCli();
+  expect(tspublish).toBeTruthy();
+});
+
+tap.start();
+```
+
+### Comprehensive usage example
+
+Let's combine all the steps into a complete example where you prepare a monorepo, configure each module, and execute the publishing workflow.
+
+Suppose you have a project structure as follows:
+
+```plaintext
+my-monorepo/
+├── ts-package1/
+│   ├── src/
+│   ├── tspublish.json
+├── ts-package2/
+│   ├── src/
+│   ├── tspublish.json
+```
+
+Follow these steps:
+
+1. Ensure each package has `tspublish.json` properly configured with necessary metadata.
+2. Create a CLI script such as `publish.js`:
+
+```typescript
+import { runCli } from '@git.zone/tspublish';
+
+runCli()
+  .then(() => {
+    console.log('Publishing completed successfully');
+  })
+  .catch((error) => {
+    console.error('Error during publishing:', error);
+  });
+```
+
+3. Execute your CLI script:
+
+```bash
+node publish.js
+```
+
+Your script will call `runCli`, which will traverse each `ts-package`, verify their publish readiness, and handle individual publishing processes.
+
+By following these comprehensive guidelines and utilizing the structured approach provided by `@git.zone/tspublish`, you can efficiently manage and publish multiple sub-packages from within a monorepo, facilitating organized, modular package management in projects of any scale.
+undefined

test/test.giteaassets.ts

@@ -0,0 +1,39 @@
+import { expect, tap } from '@push.rocks/tapbundle';
+import * as giteaAssets from '../ts/classes.giteaassets.js';
+
+let giteaAssetsInstance: giteaAssets.GiteaAssets;
+
+tap.test('should create a GiteaAssets instance', async () => {
+  giteaAssetsInstance = new giteaAssets.GiteaAssets({
+    giteaBaseUrl: 'https://code.foss.global',
+  });
+  expect(giteaAssetsInstance).toBeInstanceOf(giteaAssets.GiteaAssets);
+});
+
+tap.test('should get files from a repository', async () => {
+  const files = await giteaAssetsInstance.getFiles('git.zone', 'cli', 'assets/templates/cli');
+  console.log(files);
+
+  for (const file of files) {
+    if (file.name.endsWith('cli.js')) {
+      console.log(atob(file.base64Content));
+    }
+  }
+
+  expect(files).toBeTruthy();
+});
+
+tap.test('should get files from a repository', async () => {
+  const files = await giteaAssetsInstance.getFiles('git.zone', 'cli', 'assets/templates/cli/cli.js');
+  console.log(files);
+
+  for (const file of files) {
+    if (file.name.endsWith('cli.js')) {
+      console.log(atob(file.base64Content));
+    }
+  }
+
+  expect(files).toBeTruthy();
+});
+
+tap.start();

test/test.ts

@@ -5,4 +5,9 @@ tap.test('first test', async () => {
   console.log(tspublish);
 });
 
+tap.test('should create a TsPublish instance', async () => {
+  const tspublishInstance = new tspublish.TsPublish();
+  expect(tspublishInstance).toBeTruthy();
+});
+
 tap.start();

ts/00_commitinfo_data.ts

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

ts/classes.giteaassets.ts

@@ -0,0 +1,103 @@
+import * as plugins from './plugins.js';
+
+interface IRepoFile {
+  name: string;
+  path: string;
+  type: 'file' | 'dir';
+  download_url: string | null;
+  base64Content: string | null;
+  encoding: string | null;
+}
+
+interface IGiteaAssetsOptions {
+  giteaBaseUrl: string; // Base URL of your Gitea instance
+  token?: string; // Optional token for private repositories
+}
+
+export class GiteaAssets {
+  private baseUrl: string;
+  private headers: {[key: string]: string} = {};
+
+  constructor(options: IGiteaAssetsOptions) {
+    this.baseUrl = options.giteaBaseUrl
+    if (this.baseUrl.endsWith('/')) {
+      this.baseUrl = this.baseUrl.slice(0, -1);
+    }
+    this.baseUrl += '/api/v1';
+    this.headers = options.token
+        ? { ...this.headers, 'Authorization': `token ${options.token}` }
+        : this.headers;
+  }
+
+  /**
+   * Get all files in a directory of a repository
+   * @param owner - Repository owner
+   * @param repo - Repository name
+   * @param directory - Directory path ('' for root)
+   * @param branch - Branch name (optional)
+   * @returns A list of files in the directory
+   */
+  async getFiles(
+    owner: string,
+    repo: string,
+    directory: string,
+    branch?: string
+  ): Promise<IRepoFile[]> {
+    try {
+      const response = await plugins.smartrequest.request(
+        this.baseUrl + `/repos/${owner}/${repo}/contents/${directory}`,
+        {
+          headers: this.headers,
+          method: 'GET',
+          queryParams: branch ? { ref: branch } : {},
+        }
+      )
+      if (!Array.isArray(response.body) && typeof response.body === 'object') {
+        response.body = [response.body];
+      } else if (Array.isArray(response.body)) {
+        for (const entry of response.body) {
+          if (entry.type === 'dir') {
+            continue;
+          } else if (entry.type === 'file') {
+            const response2 = await plugins.smartrequest.request(
+              this.baseUrl + `/repos/${owner}/${repo}/contents/${entry.path}`,
+              {
+                headers: this.headers,
+                method: 'GET',
+                queryParams: branch ? { ref: branch } : {},
+              }
+            );
+            entry.encoding = response2.body.encoding;
+            entry.content = response2.body.content;
+          }
+        }
+      }
+
+      // lets map to the IRepoFile interface
+      response.body = response.body.map((entry: any) => {
+        return {
+          name: entry.name,
+          path: entry.path,
+          type: entry.type,
+          download_url: entry.download_url,
+          base64Content: entry.content,
+          encoding: entry.encoding,
+        };
+      });
+
+      return response.body;
+    } catch (error) {
+      console.error('Error fetching repository files:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * gets the current cli entry file from the code.foss.global/git.zone/cli repository
+   * @returns
+   */
+  public async getBinCliEntryFile() {
+    const files = await this.getFiles('git.zone', 'cli', 'assets/templates/cli/cli.js');
+    return files[0];
+  }
+}

ts/classes.publishmodule.ts

@@ -2,10 +2,14 @@ import * as plugins from './plugins.js';
 import * as paths from './paths.js';
 import { logger } from './logging.js';
 
+import { type ITsPublishJson } from './interfaces/index.js';
+import type { TsPublish } from './classes.tspublish.js';
+
 export interface IPublishModuleOptions {
   monoRepoDir: string;
   packageSubFolder: string;
   packageSubFolderFullPath?: string;
+  tsPublishJson?: ITsPublishJson;
   publishModDirFullPath?: string;
   name?: string;
   version?: string;
@@ -13,8 +17,10 @@ export interface IPublishModuleOptions {
 }
 
 export class PublishModule {
+  tsPublishRef: TsPublish;
   public options: IPublishModuleOptions;
-  constructor(options: IPublishModuleOptions) {
+  constructor(tsPublishRef: TsPublish, options: IPublishModuleOptions) {
+    this.tsPublishRef = tsPublishRef;
     this.options = options;
   }
 
@@ -28,29 +34,50 @@ export class PublishModule {
     if (!this.options.packageSubFolder.startsWith('ts')) {
       throw new Error('subFolder must start with "ts"');
     }
-    const jsonData = plugins.smartfile.fs.toObjectSync(
+    this.options.tsPublishJson = plugins.smartfile.fs.toObjectSync(
       plugins.path.join(this.options.packageSubFolderFullPath, 'tspublish.json')
     );
-    this.options.dependencies = this.options.dependencies || {};
+
+    // the package.json of the parent mono repo
+    const monoRepoPackageJson = JSON.parse(
+      plugins.smartfile.fs.toStringSync(plugins.path.join(this.options.monoRepoDir, 'package.json'))
+    );
+
     this.options.dependencies = {
       ...this.options.dependencies,
-      ...jsonData.dependencies,
+      ...(() => {
+        const resultDependencies = {};
+        for (const dependency of this.options.tsPublishJson.dependencies) {
+          if (monoRepoPackageJson.dependencies[dependency]) {
+            resultDependencies[dependency] = monoRepoPackageJson.dependencies[dependency];
+          } else {
+            resultDependencies[dependency] = monoRepoPackageJson.version;
+          }
+        }
+        return resultDependencies;
+      })(),
     };
-    this.options.name = this.options.name || jsonData.name;
+    this.options.name = this.options.name || this.options.tsPublishJson.name;
-    this.options.version = plugins.smartfile.fs.toObjectSync(
+    this.options.version = monoRepoPackageJson.version;
-      plugins.path.join(this.options.monoRepoDir, 'package.json')
-    ).version;
 
     // now that we have a name and version, lets check if there is already a package under the same name and version.
     const smartnpmInstance = new plugins.smartnpm.NpmRegistry({}); // TODO: pass in options
-    const packageInfo = await smartnpmInstance.getPackageInfo(this.options.name);
+    let packageInfo: plugins.smartnpm.NpmPackage;
+    try {
+      packageInfo = await smartnpmInstance.getPackageInfo(this.options.name);
+    } catch (error) {
+      logger.log('warn', `package does not yet seem to exist. Proceeding in 10 seconds...`);
+      await plugins.smartdelay.delayFor(10000);
+    }
     if (packageInfo) {
       const availableVersions = packageInfo.allVersions.map((versionArg) => versionArg.version);
       logger.log('info', `available versions are: ${availableVersions.toString()}`);
       if (availableVersions.includes(this.options.version)) {
-        throw new Error(
+        logger.log(
+          'error',
           `package ${this.options.name} already exists with version ${this.options.version}`
         );
+        process.exit(1);
       }
     }
   }
@@ -64,14 +91,42 @@ export class PublishModule {
     return packageInfo.allVersions[0].version;
   }
 
+  public async createTsconfigJson() {
+    const originalTsConfig = plugins.smartfile.fs.toObjectSync(
+      plugins.path.join(paths.cwd, 'tsconfig.json')
+    );
+    if (originalTsConfig?.compilerOptions?.paths) {
+      for (const path of Object.keys(originalTsConfig.compilerOptions.paths)) {
+        originalTsConfig.compilerOptions.paths[
+          path
+        ][0] = `.${originalTsConfig.compilerOptions.paths[path][0]}`;
+      }
+    }
+    const tsconfigJson = {
+      compilerOptions: {
+        experimentalDecorators: true,
+        useDefineForClassFields: false,
+        target: 'ES2022',
+        module: 'NodeNext',
+        moduleResolution: 'NodeNext',
+        esModuleInterop: true,
+        verbatimModuleSyntax: true,
+        paths: originalTsConfig?.compilerOptions?.paths,
+      },
+      exclude: ['dist_*/**/*.d.ts'],
+    };
+    return JSON.stringify(tsconfigJson, null, 2);
+  }
+
   public async createPackageJson() {
     const packageJson = {
       name: this.options.name,
       version: this.options.version,
+      type: 'module',
       description: '',
       exports: {
         '.': {
-          import: './dist_${this.options.packageSubFolder}/index.js',
+          import: `./dist_${this.options.packageSubFolder}/index.js`,
         },
       },
       scripts: {
@@ -81,6 +136,27 @@ export class PublishModule {
       devDependencies: {
         '@git.zone/tsbuild': await this.getLatestVersionOfPackage('@git.zone/tsbuild'),
       },
+      files: [
+        'ts/**/*',
+        'ts_*/**/*',
+        'dist/**/*',
+        'dist_*/**/*',
+        'dist_ts/**/*',
+        'dist_ts_web/**/*',
+        'assets/**/*',
+        'cli.js',
+        'npmextra.json',
+        'readme.md',
+      ],
+      ...this.options.tsPublishJson.bin ? {
+        bin: (() => {
+          const binObject: {[key: string]: string} = {};
+          for (const bin of this.options.tsPublishJson.bin) {
+            binObject[bin] = `./cli.js`;
+          }
+          return binObject;
+        })()
+      } : {},
     };
     return JSON.stringify(packageJson, null, 2);
   }
@@ -90,16 +166,81 @@ export class PublishModule {
       this.options.monoRepoDir,
       `dist_publish_${this.options.packageSubFolder}`
     );
-    
-    // package.json
     await plugins.smartfile.fs.ensureEmptyDir(this.options.publishModDirFullPath);
+
+    // package.json
     const packageJson = await plugins.smartfile.SmartFile.fromString(
       plugins.path.join(this.options.publishModDirFullPath, 'package.json'),
       await this.createPackageJson(),
       'utf8'
     );
+    await packageJson.write();
 
-    // ts folder
+    // tsconfig.json
-    await plugins.smartfile.fs.copy(this.options.packageSubFolderFullPath, plugins.path.join(this.options.publishModDirFullPath, this.options.packageSubFolder)) 
+    const tsconfigJson = await plugins.smartfile.SmartFile.fromString(
+      plugins.path.join(this.options.publishModDirFullPath, 'tsconfig.json'),
+      await this.createTsconfigJson(),
+      'utf8'
+    );
+    await tsconfigJson.write();
+
+    // ts subfolder, the folder that contains the source code and is being transpiled
+    await plugins.smartfile.fs.copy(
+      this.options.packageSubFolderFullPath,
+      plugins.path.join(this.options.publishModDirFullPath, this.options.packageSubFolder)
+    );
+
+    // readme
+    await plugins.smartfile.fs.copy(
+      plugins.path.join(this.options.packageSubFolderFullPath, 'readme.md'),
+      plugins.path.join(this.options.publishModDirFullPath, 'readme.md')
+    );
+
+    // license
+    await plugins.smartfile.fs.copy(
+      plugins.path.join(this.options.monoRepoDir, 'license'),
+      plugins.path.join(this.options.publishModDirFullPath, 'license')
+    );
+
+    // cli stuff
+    this.createBinCliSetup();
+  }
+
+  public async build() {
+    const smartshellInstance = new plugins.smartshell.Smartshell({
+      executor: 'bash',
+    });
+    await smartshellInstance.exec(`cd ${this.options.publishModDirFullPath} && pnpm run build`);
+  }
+
+  public async createBinCliSetup() {
+    const binSetupApplies: boolean =
+      this.options.tsPublishJson.bin &&
+      Array.isArray(this.options.tsPublishJson.bin) &&
+      this.options.tsPublishJson.bin.length > 0;
+    const files = await this.tsPublishRef.giteaAssetsInstance.getFiles(
+      'git.zone',
+      'cli',
+      'assets/templates/cli/cli.js'
+    );
+    const indexPath = `./dist_${this.options.packageSubFolder}/index.js`;
+    const fileContent = atob(files[0].base64Content).replace('./dist_ts/index.js', indexPath);
+    await plugins.smartfile.memory.toFs(fileContent, plugins.path.join(this.options.publishModDirFullPath, 'cli.js'));
+  }
+
+  public async publish() {
+    const smartshellInstance = new plugins.smartshell.Smartshell({
+      executor: 'bash',
+    });
+    for (const registry of this.options.tsPublishJson.registries) {
+      const registryArray = registry.split(':');
+      const registryUrl = registryArray[0];
+      const registryAccessLevel = registryArray[1];
+      await smartshellInstance.exec(
+        `cd ${this.options.publishModDirFullPath} && pnpm publish ${
+          registryAccessLevel === 'public' ? '--access public' : ''
+        } --no-git-checks --registry https://${registryUrl}`
+      );
+    }
   }
 }

ts/classes.tspublish.ts

@@ -1,25 +1,48 @@
 import { logger } from './logging.js';
 import * as plugins from './plugins.js';
+import * as interfaces from './interfaces/index.js';
 
 import { PublishModule } from './classes.publishmodule.js';
+import { GiteaAssets } from './classes.giteaassets.js';
 
 export class TsPublish {
-  constructor() {}
+  public giteaAssetsInstance: GiteaAssets;
 
-  public async publish (monorepoDirArg: string) {
+  constructor() {
-    const publishModules = await this.readDirectory(monorepoDirArg);
+    this.giteaAssetsInstance = new GiteaAssets({
-    for (const publishModule of publishModules) {
+      giteaBaseUrl: 'https://code.foss.global',
-      const publishModuleInstance = new PublishModule({
+    });
+  }
+
+  public async publish(monorepoDirArg: string) {
+    const publishModules = await this.getModuleSubDirs(monorepoDirArg);
+    logger.log('info', `Found ${Object.keys(publishModules).length} publish modules:`);
+    for (const publishModule of Object.keys(publishModules)) {
+      logger.log(
+        'info',
+        `Publishing module: ${publishModule} -> ${publishModules[publishModule].name}`
+      );
+    }
+    for (const publishModule of Object.keys(publishModules)) {
+      // lets check wether there is a name
+      if (!publishModules[publishModule].name) {
+        logger.log('warn', `no name found in tspublish.json for ${publishModule}. Skipping...`);
+        continue;
+      }
+      const publishModuleInstance = new PublishModule(this, {
         monoRepoDir: monorepoDirArg,
         packageSubFolder: publishModule,
       });
       await publishModuleInstance.init();
+      await publishModuleInstance.createPublishModuleDir();
+      await publishModuleInstance.build();
+      await publishModuleInstance.publish();
     }
   }
 
-  public async readDirectory (dirArg: string) {
+  public async getModuleSubDirs(dirArg: string) {
     const subDirs = await plugins.smartfile.fs.listFolders(dirArg);
-    const publishModules: string[] = [];
+    const publishModules: { [key: string]: interfaces.ITsPublishJson } = {};
     for (const subDir of subDirs) {
       if (!subDir.startsWith('ts')) {
         continue;
@@ -29,10 +52,15 @@ export class TsPublish {
       if (!hasPublishJson) {
         continue;
       }
+
       logger.log('info', `found publish module: ${subDir}`);
-      publishModules.push(subDir);
+      publishModules[subDir] = JSON.parse(
+        plugins.smartfile.fs.toStringSync(plugins.path.join(subDir, 'tspublish.json'))
+      );
     }
-    logger.log('ok', `found ${publishModules.length} publish modules`);
+    logger.log('ok', `found ${Object.keys(publishModules).length} publish modules`);
+    logger.log('info', `Ordering publish modules...`);
+
     return publishModules;
   }
-}
+}

ts/index.ts

@@ -1,9 +1,10 @@
 import * as paths from './paths.js';
 import { TsPublish } from './classes.tspublish.js';
 
-export * from './classes.tspublish.js'
+export * from './classes.tspublish.js';
 
 export const runCli = async () => {
+  console.log('Starting tspublish...');
   const tspublish = new TsPublish();
   await tspublish.publish(paths.cwd);
-}
+};

ts/interfaces/index.ts

@@ -0,0 +1 @@
+export * from './tspublish.js';

ts/interfaces/tspublish.ts

@@ -0,0 +1,13 @@
+export interface ITsPublishJson {
+  /**
+   * the order assures that a project is compiled before another project
+   */
+  order: number;
+  name: string;
+  dependencies: string[];
+  registries: string[];
+  /**
+   * allows the sepcification of bin names that invoke cli scripts
+   */
+  bin: string[];
+}

ts/logging.ts

@@ -1,4 +1,5 @@
 import * as plugins from './plugins.js';
 import * as commitinfo from './00_commitinfo_data.js';
 
-export const logger = plugins.smartlog.Smartlog.createForCommitinfo(commitinfo.commitinfo);
+export const logger = plugins.smartlog.Smartlog.createForCommitinfo(commitinfo.commitinfo);
+logger.enableConsole();

ts/paths.ts

@@ -2,6 +2,8 @@ import * as plugins from './plugins.js';
 
 export const cwd = process.cwd();
 
-export const packageDir = plugins.path.join(plugins.smartpath.get.dirnameFromImportMetaUrl(import.meta.url), '..');
+export const packageDir = plugins.path.join(
+  plugins.smartpath.get.dirnameFromImportMetaUrl(import.meta.url),
+  '..',
+);
 export const nogitDir = plugins.path.join(packageDir, '.nogit');
-

ts/plugins.ts

@@ -1,14 +1,15 @@
 // node native scope
 import * as path from 'path';
-export {
+export { path };
-  path,
-}
 
 // @push.rocks scope
 import * as smartfile from '@push.rocks/smartfile';
 import * as smartcli from '@push.rocks/smartcli';
+import * as smartdelay from '@push.rocks/smartdelay';
 import * as smartlog from '@push.rocks/smartlog';
 import * as smartnpm from '@push.rocks/smartnpm';
 import * as smartpath from '@push.rocks/smartpath';
+import * as smartrequest from '@push.rocks/smartrequest';
+import * as smartshell from '@push.rocks/smartshell';
 
-export { smartfile, smartcli, smartlog, smartnpm, smartpath, };
+export { smartfile, smartcli, smartdelay, smartlog, smartnpm, smartpath, smartrequest, smartshell };

tsconfig.json

@@ -6,9 +6,11 @@
     "module": "NodeNext",
     "moduleResolution": "NodeNext",
     "esModuleInterop": true,
-    "verbatimModuleSyntax": true
+    "verbatimModuleSyntax": true,
+    "baseUrl": ".",
+    "paths": {}
   },
   "exclude": [
     "dist_*/**/*.d.ts"
   ]
-}
+}