tkeron 0.0.4

package/.github/workflows/CICD.yml

@@ -0,0 +1,43 @@
+name: CICD
+
+on:
+  push:
+    branches: 
+      - main
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+      - name: Intall
+        run: npm i
+      - name: Build
+        run: npm run build
+      - name: Test
+        run: npm test
+  publish:
+    if: ${{ contains(github.event.head_commit.message, '#publish') }}
+    needs: [test]
+    name: Publish to npm
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 16.x
+          registry-url: "https://registry.npmjs.org/"
+      - name: Intall
+        run: npm i
+      - name: Build
+        run: npm run build
+      - name: cicd command
+        run: npm run cicd
+      - run: rm -rf src dist/test front web .github
+      - name: Publish
+        run: npm publish --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+          token: ${{ secrets.NPM_TOKEN }}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 tkeron
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,76 @@
+# Tkeron
+
+Micro framework for developing web user interfaces with typescript.
+
+- Create web interfaces with typescript without configuration.
+- Take advantage of hot reloading to see your changes as you go.
+- Start your project faster, compile faster than other frameworks (thanks to esbuild).
+- Create pre-rendered components or pages.
+
+
+![tkeron example](./assets/tkexample.gif)
+
+**How to use**
+
+
+---
+- Install tkeron globally
+
+```bash
+npm i -g tkeron
+```
+
+---
+- Enter in your project directory and run:
+
+```bash
+tkeron init
+```
+
+This will create a blank project in the "front" directory.
+
+---
+- To build the html file run this:
+
+```bash
+tkeron build
+```
+
+This will transpile the project in the directory "web"
+
+---
+- To run in your browser:
+
+```bash
+tkeron dev
+```
+
+This command will create a server on port 5000 for the "web" directory and will observe the file change in the "front" directory.
+
+---
+- to create a page use this:
+
+```bash
+tkeron generate page index
+```
+
+or its short version: 
+
+```bash
+tk g p index
+```
+
+---
+- to create a component use this:
+
+```bash
+tkeron generate component my/button
+```
+
+or its short version: 
+
+```bash
+tk g c my/button
+```
+
+

package/changelog.md

@@ -0,0 +1,8 @@
+# v0.0.4
+
+- update bundleTs function to allow delete outfile.
+
+# v0.0.3
+
+- fix error in simpleHotRestart script due to undefined "exports" variable.
+

package/dist/base64.d.ts

@@ -0,0 +1,2 @@
+export declare const fromBase64: (base64str: string) => string;
+export declare const toBase64: (base64str: string) => string;

package/dist/base64.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toBase64 = exports.fromBase64 = void 0;
+const fromBase64 = (base64str) => Buffer.from(base64str, "base64").toString("utf-8");
+exports.fromBase64 = fromBase64;
+const toBase64 = (base64str) => Buffer.from(base64str, "utf-8").toString("base64");
+exports.toBase64 = toBase64;

package/dist/build.d.ts

@@ -0,0 +1,10 @@
+export interface buildArguments {
+    sourceDir: string;
+    outputDir: string;
+    hotRestart?: boolean;
+    ignoreConsoleLogs?: boolean;
+    ignoreErrors?: boolean;
+    minify?: boolean;
+}
+export declare const build: (args: buildArguments, minify?: boolean) => Promise<void>;
+export declare const tryBuildFront: (name: string, html: string, outHtmlFile: string, hotRestart: boolean, outTsFile: string, scriptId: string, tsFile: string, minify?: boolean) => Promise<[boolean, string, CallableFunction]>;

package/dist/build.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryBuildFront = exports.build = void 0;
+const path_1 = require("path");
+const promises_1 = require("fs/promises");
+const fileExist_1 = require("./fileExist");
+const generateItems_1 = require("./generateItems");
+const getDocument_1 = require("./getDocument");
+const getFilesRecursive_1 = require("./getFilesRecursive");
+const getOptions_1 = require("./getOptions");
+const injectTsFile_1 = require("./injectTsFile");
+const rnd_1 = require("./rnd");
+const buildFront_1 = require("./buildFront");
+const serializeDocument_1 = require("./serializeDocument");
+const backRegex = /\.back\.ts$/;
+const htmlPageRegex = /\.page\.html$/;
+const build = async (args, minify = true) => {
+    const { hotRestart, ignoreConsoleLogs, ignoreErrors } = args;
+    const { outputDir, sourceDir } = (0, getOptions_1.getOptions)({ sourceDir: args.sourceDir, outputDir: args.outputDir });
+    if (!await (0, fileExist_1.fileExists)(sourceDir))
+        throw "directory does not exist";
+    await (0, promises_1.mkdir)(outputDir, { recursive: true });
+    const pagesReady = [];
+    const backFiles = [...(0, getFilesRecursive_1.getFilesRecursive)(sourceDir, { pattern: backRegex })];
+    const buildFrontPromises = [];
+    for (const file of backFiles) {
+        const name = (0, path_1.basename)(file).replace(backRegex, "");
+        const htmlFile = file.replace(backRegex, ".page.html");
+        pagesReady.push(htmlFile);
+        const htmlExist = await (0, fileExist_1.fileExists)(htmlFile);
+        let html = htmlExist ? await (0, promises_1.readFile)(htmlFile, { encoding: "utf-8" }) : (0, generateItems_1.pageItem)(name).html;
+        const scriptId = "tmp" + (0, rnd_1.rnds)(25);
+        html = await (0, injectTsFile_1.injectTsFile)({ html, outputDir, sourceDir, tsFile: file, scriptId });
+        const { document, jsDomErrors, window } = (0, getDocument_1.getDocument)(html, { ignoreConsoleLogs, ignoreErrors });
+        if (ignoreErrors && jsDomErrors.length)
+            jsDomErrors.forEach((_) => console["log"](`page ${name} error: `, _.detail || _));
+        await new Promise((ok) => {
+            const handle = setTimeout(() => {
+                console["log"](`time up: ${name}`);
+                ok(0);
+            }, 6e3);
+            document.addEventListener("load", () => {
+                clearTimeout(handle);
+                ok(0);
+            });
+        });
+        const scriptNode = document.querySelector(`#${scriptId}`);
+        if (scriptNode)
+            document.head.removeChild(scriptNode);
+        html = (0, serializeDocument_1.serializeDocument)(document);
+        window.close();
+        const tsFile = htmlFile.replace(htmlPageRegex, ".page.ts");
+        const outHtmlFile = file.replace(sourceDir, outputDir).replace(backRegex, ".html");
+        const outTsFile = file.replace(sourceDir, outputDir).replace(backRegex, ".js");
+        html = html.replace(/\/\*tkeron\-front\-script/g, "");
+        html = html.replace(/tkeron\-front\-script\*\//g, "");
+        buildFrontPromises.push((0, exports.tryBuildFront)(name, html, outHtmlFile, hotRestart, outTsFile, "tkeron_page_js", tsFile, minify));
+    }
+    const htmlFiles = [...(0, getFilesRecursive_1.getFilesRecursive)(sourceDir, { pattern: htmlPageRegex })];
+    for (const file of htmlFiles) {
+        const name = (0, path_1.basename)(file).replace(htmlPageRegex, "");
+        if (pagesReady.includes(file))
+            continue;
+        let html = await (0, promises_1.readFile)(file, { encoding: "utf-8" });
+        const outHtmlFile = file.replace(sourceDir, outputDir).replace(htmlPageRegex, ".html");
+        const outTsFile = file.replace(sourceDir, outputDir).replace(htmlPageRegex, ".html");
+        const tsFile = file.replace(htmlPageRegex, ".page.ts");
+        html = html.replace(/\/\*tkeron\-front\-script/g, "");
+        html = html.replace(/tkeron\-front\-script\*\//g, "");
+        buildFrontPromises.push((0, exports.tryBuildFront)(name, html, outHtmlFile, hotRestart, outTsFile, "tkeron_page_js", tsFile, minify));
+    }
+    const results = await Promise.all(buildFrontPromises);
+    for (const result of results) {
+        const [ok, name, retry] = result;
+        if (ok)
+            continue;
+        console["log"](`\nretry build ${name}...`);
+        await new Promise((done) => setTimeout(done, 300));
+        const [done] = await retry();
+        if (!done)
+            throw `error building ${name}, try build command again...`;
+    }
+    const compdate = new Date().getTime().toString();
+    const compdateDir = (0, path_1.join)(outputDir, "compdate.txt");
+    await (0, promises_1.writeFile)(compdateDir, compdate, { encoding: "utf-8" });
+    console["log"]("\nall site built");
+};
+exports.build = build;
+const tryBuildFront = async (name, html, outHtmlFile, hotRestart, outTsFile, scriptId, tsFile, minify = true) => {
+    return new Promise(async (ok) => {
+        try {
+            await (0, buildFront_1.buildFront)({ html, outHtmlFile, hotRestart, outTsFile, scriptId: "tkeron_page_js", tsFile, minify });
+            console["log"](`site ${name} built`);
+            ok([true, name, async () => { }]);
+        }
+        catch (_) {
+            console["log"](`error building site ${name}: `, _);
+            ok([false, name, () => (0, exports.tryBuildFront)(name, html, outHtmlFile, hotRestart, outTsFile, scriptId, tsFile)]);
+        }
+    });
+};
+exports.tryBuildFront = tryBuildFront;

package/dist/buildFront.d.ts

@@ -0,0 +1,10 @@
+export interface buildFrontOptions {
+    html: string;
+    tsFile: string;
+    outTsFile: string;
+    outHtmlFile: string;
+    hotRestart?: boolean;
+    scriptId: string;
+    minify?: boolean;
+}
+export declare const buildFront: (options: buildFrontOptions) => Promise<string>;

package/dist/buildFront.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildFront = void 0;
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const bundleTs_1 = require("./bundleTs");
+const fileExist_1 = require("./fileExist");
+const injectCode_1 = require("./injectCode");
+const buildFront = async (options) => {
+    const { hotRestart, outHtmlFile, scriptId, tsFile, outTsFile, minify } = options;
+    let { html } = options;
+    const outHtmlDir = (0, path_1.dirname)(outHtmlFile);
+    if (hotRestart === true) {
+        const code = await (0, bundleTs_1.bundleTs)((0, path_1.join)(__dirname, "..", "distFiles", "simpleHotRestart.ts"), "shr.js", true, true);
+        html = (0, injectCode_1.injectCode)(html, code, "tkeron_simple_hot_restart");
+    }
+    if (await (0, fileExist_1.fileExists)(tsFile)) {
+        const tsCode = await (0, bundleTs_1.bundleTs)(tsFile, outTsFile, minify);
+        await (0, promises_1.unlink)(outTsFile);
+        if (tsCode.trim() !== "")
+            html = (0, injectCode_1.injectCode)(html, tsCode, scriptId);
+    }
+    await (0, promises_1.mkdir)(outHtmlDir, { recursive: true });
+    await (0, promises_1.writeFile)(outHtmlFile, html, { encoding: "utf-8" });
+    return html;
+};
+exports.buildFront = buildFront;

package/dist/buildLoaders.d.ts

@@ -0,0 +1,13 @@
+import { Loader } from "esbuild";
+export declare const buildLoaders: {
+    ".jpg": Loader;
+    ".png": Loader;
+    ".gif": Loader;
+    ".ico": Loader;
+    ".webp": Loader;
+    ".svg": Loader;
+    ".js": Loader;
+    ".css": Loader;
+    ".html": Loader;
+};
+export declare const getExtModules: () => string;

package/dist/buildLoaders.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExtModules = exports.buildLoaders = void 0;
+exports.buildLoaders = {
+    ".jpg": "file",
+    ".png": "file",
+    ".gif": "file",
+    ".ico": "file",
+    ".webp": "file",
+    ".svg": "file",
+    ".js": "file",
+    ".css": "text",
+    ".html": "text",
+};
+const getExtModules = () => {
+    let content = "";
+    const exts = Object.keys(exports.buildLoaders).sort();
+    for (const ext of exts) {
+        content += `declare module '*${ext}';\n`;
+    }
+    return content;
+};
+exports.getExtModules = getExtModules;

package/dist/bundleTs.d.ts

@@ -0,0 +1 @@
+export declare const bundleTs: (file: string, outfile: string, minify?: boolean, deleteOutfile?: boolean) => Promise<string>;

package/dist/bundleTs.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bundleTs = void 0;
+const path_1 = require("path");
+const fileExist_1 = require("./fileExist");
+const esbuild_1 = require("esbuild");
+const buildLoaders_1 = require("./buildLoaders");
+const promises_1 = require("fs/promises");
+const bundleTs = async (file, outfile, minify = true, deleteOutfile = false) => {
+    if (!file)
+        throw "file must be defined";
+    if (!outfile)
+        throw "outfile must be defined";
+    file = (0, path_1.normalize)(file);
+    const exist = await (0, fileExist_1.fileExists)(file);
+    if (!exist)
+        throw `file ${file} doesn't exist`;
+    const minifySyntax = minify;
+    const minifyWhitespace = minify;
+    const buildResult = await (0, esbuild_1.build)({
+        entryPoints: [file],
+        outfile,
+        bundle: true,
+        minifySyntax,
+        minifyWhitespace,
+        loader: buildLoaders_1.buildLoaders,
+    });
+    if (buildResult.errors.length)
+        throw buildResult.errors;
+    const tsResult = await (0, promises_1.readFile)(outfile, { encoding: "utf-8" });
+    if (deleteOutfile)
+        await (0, promises_1.unlink)(outfile);
+    return tsResult;
+};
+exports.bundleTs = bundleTs;

package/dist/cicd.d.ts

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

package/dist/cicd.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const path_1 = require("path");
+const libFiles_ts_1 = require("./libFiles.ts");
+for (const file of libFiles_ts_1.libFiles) {
+    (0, fs_1.copyFileSync)((0, path_1.join)("src", file), (0, path_1.join)("distFiles", file));
+}

package/dist/cmdBuild.d.ts

@@ -0,0 +1 @@
+export declare const cmdBuild: (sourceDir?: string, outputDir?: string) => Promise<void>;

package/dist/cmdBuild.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cmdBuild = void 0;
+const build_1 = require("./build");
+const cmdBuild = (sourceDir, outputDir) => (0, build_1.build)({
+    sourceDir, outputDir,
+    hotRestart: false,
+    ignoreConsoleLogs: true,
+    ignoreErrors: true
+});
+exports.cmdBuild = cmdBuild;

package/dist/cmdDev.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+import { Server } from "http";
+export declare const dev: (sourceDir: string, outputDir: string, port?: number, addr?: string) => Promise<{
+    closeWatcher: () => void;
+    closeServer: () => Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>;
+}>;
+export declare const cmdDev: (sourceDir: string, outputDir: string, port?: number, addr?: string) => Promise<void>;

package/dist/cmdDev.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cmdDev = exports.dev = void 0;
+const express_1 = __importDefault(require("express"));
+const node_watch_1 = __importDefault(require("node-watch"));
+const stream_1 = require("stream");
+const build_1 = require("./build");
+const fileExist_1 = require("./fileExist");
+const getOptions_1 = require("./getOptions");
+const dev = async (sourceDir, outputDir, port = 5000, addr = "127.0.0.1") => {
+    const opts = (0, getOptions_1.getOptions)({ outputDir, sourceDir });
+    sourceDir = opts.sourceDir;
+    outputDir = opts.outputDir;
+    if (!(await (0, fileExist_1.fileExists)(sourceDir)))
+        throw `source directory doesn't exist`;
+    await (0, build_1.build)({ sourceDir, outputDir, hotRestart: true });
+    let building = false;
+    let rebuild = false;
+    const events = new stream_1.EventEmitter();
+    const watcher = (0, node_watch_1.default)(sourceDir, { recursive: true }, async (_event, _) => {
+        if (building) {
+            rebuild = true;
+            return;
+        }
+        building = true;
+        await (0, build_1.build)({ sourceDir, outputDir, hotRestart: true });
+        if (rebuild)
+            await (0, build_1.build)({ sourceDir, outputDir, hotRestart: true });
+        events.emit("built");
+        building = false;
+    });
+    const app = (0, express_1.default)();
+    let firstRequest = true;
+    app.get("/compdate.txt", (_request, reply) => {
+        if (firstRequest) {
+            firstRequest = false;
+            reply.send({ reload: true });
+            return;
+        }
+        const lastListener = () => reply.send({ reload: true });
+        events.once("built", lastListener);
+    });
+    app.use(express_1.default.static(outputDir));
+    let server;
+    try {
+        server = app.listen(port, addr, () => console["log"](`linstening on ${addr}:${port}`));
+    }
+    catch (_) {
+        console["log"]("error starting local dev server", _);
+    }
+    return {
+        closeWatcher: () => watcher.close(),
+        closeServer: () => server.close(),
+    };
+};
+exports.dev = dev;
+const cmdDev = async (sourceDir, outputDir, port = 5000, addr = "127.0.0.1") => {
+    await (0, exports.dev)(sourceDir, outputDir, port, addr);
+};
+exports.cmdDev = cmdDev;

package/dist/cmdGenerate.d.ts

@@ -0,0 +1 @@
+export declare const cmdGenerate: (item: string, path: string) => Promise<void>;

package/dist/cmdGenerate.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cmdGenerate = void 0;
+const colorette_1 = require("colorette");
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const generateItems_1 = require("./generateItems");
+const getOptions_1 = require("./getOptions");
+const cmdGenerate = async (item, path) => {
+    const { sourceDir } = (0, getOptions_1.getOptions)();
+    const name = (0, path_1.basename)(path);
+    if (!generateItems_1.validItems.includes(item)) {
+        console["log"]((0, colorette_1.red)(`item "${item}" does not exist`));
+        return;
+    }
+    if (item === "component" || item === "c") {
+        const { css, ts } = (0, generateItems_1.componentItem)(name);
+        if (path.slice(0, 2) !== "./")
+            path = (0, path_1.join)("comps", path);
+        const tsFilePath = (0, path_1.join)(sourceDir, path, `${name}.ts`);
+        const cssFilePath = (0, path_1.join)(sourceDir, path, `${name}.css`);
+        const tsDir = (0, path_1.dirname)(tsFilePath);
+        await (0, promises_1.mkdir)(tsDir, { recursive: true });
+        await (0, promises_1.writeFile)(tsFilePath, ts, { encoding: "utf-8" });
+        await (0, promises_1.writeFile)(cssFilePath, css, { encoding: "utf-8" });
+    }
+    if (item === "page" || item === "p") {
+        const { css, ts, back, html } = (0, generateItems_1.pageItem)(name);
+        const tsFilePath = (0, path_1.join)(sourceDir, `${path}.page.ts`);
+        const cssFilePath = (0, path_1.join)(sourceDir, `${path}.page.css`);
+        const htmlFilePath = (0, path_1.join)(sourceDir, `${path}.page.html`);
+        const backFilePath = (0, path_1.join)(sourceDir, `${path}.back.ts`);
+        const tsDir = (0, path_1.dirname)(tsFilePath);
+        await (0, promises_1.mkdir)(tsDir, { recursive: true });
+        await (0, promises_1.writeFile)(tsFilePath, ts, { encoding: "utf-8" });
+        await (0, promises_1.writeFile)(cssFilePath, css, { encoding: "utf-8" });
+        await (0, promises_1.writeFile)(htmlFilePath, html, { encoding: "utf-8" });
+        await (0, promises_1.writeFile)(backFilePath, back, { encoding: "utf-8" });
+    }
+};
+exports.cmdGenerate = cmdGenerate;

package/dist/cmdInit.d.ts

@@ -0,0 +1 @@
+export declare const cmdInit: (sourceDir?: string, outputDir?: string) => Promise<void>;

package/dist/cmdInit.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cmdInit = void 0;
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const buildLoaders_1 = require("./buildLoaders");
+const copyDir_1 = require("./copyDir");
+const createModFile_1 = require("./createModFile");
+const createTsConfigFile_1 = require("./createTsConfigFile");
+const fileExist_1 = require("./fileExist");
+const getOptions_1 = require("./getOptions");
+const libFiles_ts_1 = require("./libFiles.ts");
+const cmdInit = async (sourceDir, outputDir) => {
+    const options = (0, getOptions_1.getOptions)({ sourceDir, outputDir });
+    sourceDir = options.sourceDir;
+    await (0, promises_1.writeFile)("tkeron.json", JSON.stringify(options, null, 4));
+    await (0, createTsConfigFile_1.createTsConfigFile)();
+    if (!await (0, fileExist_1.fileExists)(sourceDir))
+        await (0, promises_1.mkdir)(sourceDir, { recursive: true });
+    const tklibs = (0, path_1.join)(sourceDir, "tklibs");
+    if (!await (0, fileExist_1.fileExists)(tklibs))
+        await (0, promises_1.mkdir)(tklibs, { recursive: true });
+    for (const file of libFiles_ts_1.libFiles) {
+        const dest = (0, path_1.join)(tklibs, file);
+        const src = (0, path_1.join)(__dirname, "..", "distFiles", file);
+        await (0, promises_1.copyFile)(src, dest);
+    }
+    await (0, createModFile_1.createModFile)(sourceDir);
+    const extModules = (0, buildLoaders_1.getExtModules)();
+    const extModName = (0, path_1.join)(tklibs, "extensions.d.ts");
+    await (0, promises_1.writeFile)(extModName, extModules, { encoding: "utf-8" });
+    const rxjsSrc = (0, path_1.join)(__dirname, "..", "node_modules", "rxjs", "src");
+    const rxjsDest = (0, path_1.join)(tklibs, "rxjs");
+    await (0, copyDir_1.copyDir)(rxjsSrc, rxjsDest);
+};
+exports.cmdInit = cmdInit;

package/dist/copyDir.d.ts

@@ -0,0 +1 @@
+export declare const copyDir: (sourceDir: string, outputDir: string) => Promise<void>;

package/dist/copyDir.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copyDir = void 0;
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const fileExist_1 = require("./fileExist");
+const getFilesRecursive_1 = require("./getFilesRecursive");
+const copyDir = async (sourceDir, outputDir) => {
+    for (const file of (0, getFilesRecursive_1.getFilesRecursive)(sourceDir, { useDirectoryBase: true })) {
+        const sourcePath = (0, path_1.join)(sourceDir, file);
+        const outPath = (0, path_1.join)(outputDir, file);
+        const dir = (0, path_1.dirname)(outPath);
+        if (!await (0, fileExist_1.fileExists)(dir))
+            await (0, promises_1.mkdir)(dir, { recursive: true });
+        await (0, promises_1.copyFile)(sourcePath, outPath);
+    }
+};
+exports.copyDir = copyDir;

package/dist/createModFile.d.ts

@@ -0,0 +1 @@
+export declare const createModFile: (sourceDir: string) => Promise<void>;

package/dist/createModFile.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createModFile = void 0;
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const libFiles_ts_1 = require("./libFiles.ts");
+const createModFile = async (sourceDir) => {
+    let modFile = "";
+    const modFilePath = (0, path_1.join)(sourceDir, "tklibs", "mod.ts");
+    for (const file of libFiles_ts_1.libFiles)
+        modFile += `export * from "./${file.replace(/\.ts$/, "")}";\n`;
+    await (0, promises_1.writeFile)(modFilePath, modFile, { encoding: "utf-8" });
+};
+exports.createModFile = createModFile;

package/dist/createTsConfigFile.d.ts

@@ -0,0 +1 @@
+export declare const createTsConfigFile: () => Promise<void>;