@intuned/runtime-dev 0.0.1-split.0

package/src/commands/ts-check.ts

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+import * as ts from "typescript";
+import { program } from "commander";
+import * as fs from "fs-extra";
+import * as path from "path";
+import { moveWebTemplateFiles } from "./common/utils/webTemplate";
+
+program
+  .description("Check TypeScript types in the project")
+  .allowUnknownOption()
+  .action(async () => {
+    await moveWebTemplateFiles();
+
+    const templateTsConfig = path.resolve(
+      __dirname,
+      "..",
+      "..",
+      "template.tsconfig.json"
+    );
+    await fs.copy(templateTsConfig, "./intuned/WebTemplate/tsconfig.json");
+
+    checkTypes();
+  });
+
+function checkTypes() {
+  const configPath = ts.findConfigFile(
+    "./intuned/WebTemplate",
+    ts.sys.fileExists,
+    "tsconfig.json"
+  );
+
+  if (!configPath) {
+    console.error("Could not find a valid 'tsconfig.json'.");
+    process.exit(1);
+  }
+
+  const readConfigResult = ts.readConfigFile(configPath, ts.sys.readFile);
+  const config = readConfigResult.config;
+
+  const parseConfigHost = {
+    useCaseSensitiveFileNames: ts.sys.useCaseSensitiveFileNames,
+    readDirectory: ts.sys.readDirectory,
+    fileExists: ts.sys.fileExists,
+    readFile: ts.sys.readFile,
+  };
+
+  const parsed = ts.parseJsonConfigFileContent(
+    config,
+    parseConfigHost,
+    "./intuned"
+  );
+
+  const program = ts.createProgram(parsed.fileNames, parsed.options);
+  const emitResult = program.emit();
+
+  const allDiagnostics = ts
+    .getPreEmitDiagnostics(program)
+    .concat(emitResult.diagnostics);
+
+  allDiagnostics.forEach((diagnostic) => {
+    if (diagnostic.file) {
+      const { line, character } = ts.getLineAndCharacterOfPosition(
+        diagnostic.file,
+        diagnostic.start!
+      );
+      const message = ts.flattenDiagnosticMessageText(
+        diagnostic.messageText,
+        "\n"
+      );
+      console.log(
+        `${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`
+      );
+    } else {
+      console.log(
+        ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n")
+      );
+    }
+  });
+
+  if (allDiagnostics.length === 0) {
+    console.log("✨ TypeScript type checking passed without errors.");
+  } else {
+    console.error("Errors found during TypeScript type checking.");
+    process.exit(1);
+  }
+}
+
+program.parse(process.argv);

package/src/common/Logger/Logger/index.ts

@@ -0,0 +1,64 @@
+import { formatWithOptions } from "node:util";
+import { LogEntry, LogLevel, LogMetadata } from "./types";
+import chalk from "chalk";
+
+const format = formatWithOptions.bind(undefined, { colors: true });
+
+const LOG_LEVEL_COLORS: Record<LogLevel, chalk.Chalk> = {
+  TRACE: chalk.gray,
+  DEBUG: chalk.blue,
+  INFO: chalk.green,
+  WARN: chalk.yellow,
+  ERROR: chalk.red,
+};
+
+class Logger {
+  logFunction(entry: LogEntry): void {
+    const { level, timestamp, message, meta } = entry;
+    const date = new Date(timestamp);
+    const levelColor = LOG_LEVEL_COLORS[level];
+
+    if (meta === undefined) {
+      process.stderr.write(
+        `${format(date)} [@intuned/sdk][${levelColor(level)}] ${message}\n`
+      );
+    } else {
+      process.stderr.write(
+        `${format(date)} [@intuned/sdk][${levelColor(
+          level
+        )}] ${message} ${format(meta)}\n`
+      );
+    }
+  }
+
+  private log(level: LogLevel, message: string, meta?: LogMetadata): void {
+    this.logFunction({
+      level,
+      message,
+      meta: meta && Object.keys(meta).length === 0 ? undefined : meta,
+      timestamp: Date.now(),
+    });
+  }
+
+  trace(message: string, meta?: LogMetadata): void {
+    this.log("TRACE", message, meta);
+  }
+
+  debug(message: string, meta?: LogMetadata): void {
+    this.log("DEBUG", message, meta);
+  }
+
+  info(message: string, meta?: LogMetadata): void {
+    this.log("INFO", message, meta);
+  }
+
+  warn(message: string, meta?: LogMetadata): void {
+    this.log("WARN", message, meta);
+  }
+
+  error(message: string, meta?: LogMetadata): void {
+    this.log("ERROR", message, meta);
+  }
+}
+
+export const logger = new Logger();

package/src/common/Logger/Logger/types.ts

@@ -0,0 +1,9 @@
+export type LogLevel = "TRACE" | "DEBUG" | "INFO" | "WARN" | "ERROR";
+export type LogMetadata = Record<string | symbol, any>;
+
+export interface LogEntry {
+  level: LogLevel;
+  message: string;
+  timestamp: number;
+  meta?: LogMetadata;
+}

package/src/common/Logger/index.ts

@@ -0,0 +1,64 @@
+import { formatWithOptions } from "node:util";
+import { LogEntry, LogLevel, LogMetadata } from "./types";
+import chalk from "chalk";
+
+const format = formatWithOptions.bind(undefined, { colors: true });
+
+const LOG_LEVEL_COLORS: Record<LogLevel, chalk.Chalk> = {
+  TRACE: chalk.gray,
+  DEBUG: chalk.blue,
+  INFO: chalk.green,
+  WARN: chalk.yellow,
+  ERROR: chalk.red,
+};
+
+class Logger {
+  logFunction(entry: LogEntry): void {
+    const { level, timestamp, message, meta } = entry;
+    const date = new Date(timestamp);
+    const levelColor = LOG_LEVEL_COLORS[level];
+
+    if (meta === undefined) {
+      process.stderr.write(
+        `${format(date)} [@intuned/sdk][${levelColor(level)}] ${message}\n`
+      );
+    } else {
+      process.stderr.write(
+        `${format(date)} [@intuned/sdk][${levelColor(
+          level
+        )}] ${message} ${format(meta)}\n`
+      );
+    }
+  }
+
+  private log(level: LogLevel, message: string, meta?: LogMetadata): void {
+    this.logFunction({
+      level,
+      message,
+      meta: meta && Object.keys(meta).length === 0 ? undefined : meta,
+      timestamp: Date.now(),
+    });
+  }
+
+  trace(message: string, meta?: LogMetadata): void {
+    this.log("TRACE", message, meta);
+  }
+
+  debug(message: string, meta?: LogMetadata): void {
+    this.log("DEBUG", message, meta);
+  }
+
+  info(message: string, meta?: LogMetadata): void {
+    this.log("INFO", message, meta);
+  }
+
+  warn(message: string, meta?: LogMetadata): void {
+    this.log("WARN", message, meta);
+  }
+
+  error(message: string, meta?: LogMetadata): void {
+    this.log("ERROR", message, meta);
+  }
+}
+
+export const logger = new Logger();

package/src/common/Logger/types.ts

@@ -0,0 +1,9 @@
+export type LogLevel = "TRACE" | "DEBUG" | "INFO" | "WARN" | "ERROR";
+export type LogMetadata = Record<string | symbol, any>;
+
+export interface LogEntry {
+  level: LogLevel;
+  message: string;
+  timestamp: number;
+  meta?: LogMetadata;
+}