@kosdev-code/kos-ui-cli 2.1.39 → 3.0.0

package/src/lib/generators/project/splash.mjs

@@ -1,29 +1,694 @@
-// generators/project/splash.mjs
-import { actionFactory } from "../../utils/action-factory.mjs";
-import { execute } from "../../utils/exec.mjs";
-import { required } from "../../utils/validators.mjs";
+// ../kos-codegen-core/src/lib/codegen-filesystem.ts
+import * as fs from "fs";
+import * as path from "path";
+var TrackingFileSystem = class {
+  inner;
+  _writtenPaths = [];
+  constructor(inner) {
+    this.inner = inner;
+  }
+  get root() {
+    return this.inner.root;
+  }
+  get writtenPaths() {
+    return [...this._writtenPaths];
+  }
+  read(filePath) {
+    return this.inner.read(filePath);
+  }
+  write(filePath, content) {
+    this.inner.write(filePath, content);
+    this._writtenPaths.push(
+      path.isAbsolute(filePath) ? filePath : path.join(this.inner.root, filePath)
+    );
+  }
+  exists(filePath) {
+    return this.inner.exists(filePath);
+  }
+  delete(filePath) {
+    this.inner.delete(filePath);
+  }
+  listFiles(dirPath) {
+    return this.inner.listFiles(dirPath);
+  }
+};
+var DirectFileSystem = class {
+  root;
+  constructor(workspaceRoot) {
+    this.root = path.resolve(workspaceRoot);
+  }
+  read(filePath) {
+    const abs = this.resolve(filePath);
+    try {
+      return fs.readFileSync(abs, "utf-8");
+    } catch {
+      return null;
+    }
+  }
+  write(filePath, content) {
+    const abs = this.resolve(filePath);
+    fs.mkdirSync(path.dirname(abs), { recursive: true });
+    fs.writeFileSync(abs, content, "utf-8");
+  }
+  exists(filePath) {
+    return fs.existsSync(this.resolve(filePath));
+  }
+  delete(filePath) {
+    const abs = this.resolve(filePath);
+    try {
+      fs.unlinkSync(abs);
+    } catch {
+    }
+  }
+  listFiles(dirPath) {
+    const abs = this.resolve(dirPath);
+    if (!fs.existsSync(abs)) {
+      return [];
+    }
+    return this.walkDir(abs).map((file) => path.relative(this.root, file));
+  }
+  resolve(filePath) {
+    if (path.isAbsolute(filePath)) {
+      return filePath;
+    }
+    return path.join(this.root, filePath);
+  }
+  walkDir(dir) {
+    const results = [];
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        results.push(...this.walkDir(full));
+      } else {
+        results.push(full);
+      }
+    }
+    return results;
+  }
+};
 
-export const metadata = {
-  key: "project:splash",
-  name: "KOS Splash Screen Project",
-  invalidateCache: true,
-  namedArguments: { name: "name" },
+// ../kos-codegen-core/src/lib/generate-files.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import * as ejs from "ejs";
+
+// ../kos-codegen-core/src/lib/logger.ts
+var noopLogger = {
+  debug: () => {
+  },
+  info: () => {
+  },
+  warn: () => {
+  },
+  error: () => {
+  }
 };
-export default async function (plop) {
-  plop.setActionType("createSplashProject", async function (answers) {
-    const command = `npx nx generate @kosdev-code/kos-nx-plugin:kos-splash-project \
-      --name=${answers.name} \
-      --no-interactive`;
+var activeLogger = noopLogger;
+function getCodegenLogger() {
+  return activeLogger;
+}
+
+// ../kos-codegen-core/src/lib/generate-files.ts
+function generateFilesFromTemplates(codegenFs, srcFolder, destFolder, substitutions) {
+  const logger = getCodegenLogger();
+  const templateFiles = walkTemplateDir(srcFolder);
+  for (const templateFile of templateFiles) {
+    const relPath = path2.relative(srcFolder, templateFile);
+    let destRelPath = interpolateFilename(relPath, substitutions);
+    if (destRelPath.endsWith(".template")) {
+      destRelPath = destRelPath.slice(0, -".template".length);
+    }
+    const destPath = path2.join(destFolder, destRelPath);
+    const rawContent = fs2.readFileSync(templateFile, "utf-8");
+    const rendered = ejs.render(rawContent, substitutions, {
+      filename: templateFile
+      // for EJS error messages and includes
+    });
+    logger.debug(`Generating ${destPath}`);
+    codegenFs.write(destPath, rendered);
+  }
+}
+function interpolateFilename(filePath, substitutions) {
+  return filePath.replace(/__([^_]+)__/g, (match, key) => {
+    if (key in substitutions) {
+      return String(substitutions[key]);
+    }
+    return match;
+  });
+}
+function walkTemplateDir(dir) {
+  const results = [];
+  const entries = fs2.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const full = path2.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...walkTemplateDir(full));
+    } else {
+      results.push(full);
+    }
+  }
+  return results;
+}
 
+// ../kos-codegen-core/src/lib/project-discovery.ts
+import fg from "fast-glob";
+
+// ../kos-codegen-core/src/lib/format-files.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+import prettier from "prettier";
+var FORMATTABLE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".json",
+  ".css",
+  ".scss",
+  ".md",
+  ".yaml",
+  ".yml",
+  ".html"
+]);
+async function formatFiles(workspaceRoot, filePaths) {
+  const logger = getCodegenLogger();
+  for (const filePath of filePaths) {
+    const ext = path3.extname(filePath);
+    if (!FORMATTABLE_EXTENSIONS.has(ext)) {
+      continue;
+    }
     try {
-      await execute(command);
-    } catch (error) {
-      throw new Error(error);
+      const content = fs3.readFileSync(filePath, "utf-8");
+      const options = await prettier.resolveConfig(filePath, {
+        editorconfig: true
+      });
+      const formatted = await prettier.format(content, {
+        ...options,
+        filepath: filePath
+      });
+      fs3.writeFileSync(filePath, formatted, "utf-8");
+      logger.debug(`Formatted ${path3.relative(workspaceRoot, filePath)}`);
+    } catch (err) {
+      logger.warn(`Failed to format ${filePath}: ${err}`);
+    }
+  }
+}
+
+// ../kos-codegen-core/src/lib/name-utils.ts
+function dashCase(input) {
+  return input.replace(/\s+/g, "-").replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+}
+function camelCase(input) {
+  if (input.length === 0)
+    return "";
+  const words = input.split(/-|\s+/);
+  if (words.length > 0 && words[0].length > 0) {
+    words[0] = words[0].charAt(0).toLowerCase() + words[0].slice(1);
+  }
+  for (let i = 1; i < words.length; i++) {
+    words[i] = words[i].charAt(0).toUpperCase() + words[i].slice(1);
+  }
+  return words.join("");
+}
+function pascalCase(input) {
+  if (input.length === 0)
+    return "";
+  const cc = camelCase(input);
+  return cc[0].toUpperCase() + cc.slice(1);
+}
+function properCase(input) {
+  const words = input.toLowerCase().replaceAll("-", " ").split(" ").filter(Boolean);
+  for (let i = 0; i < words.length; i++) {
+    words[i] = words[i][0].toUpperCase() + words[i].slice(1);
+  }
+  return words.join("");
+}
+function constantCase(input) {
+  if (input.length === 0)
+    return "";
+  return input.toUpperCase().split(/[\s-]+/).filter(Boolean).join("_");
+}
+
+// ../kos-codegen-core/src/lib/normalize-values.ts
+var normalizeValue = (optionsName, value) => ({
+  [`${camelCase(optionsName)}CamelCase`]: camelCase(value),
+  [`${camelCase(optionsName)}ConstantCase`]: constantCase(value),
+  [`${camelCase(optionsName)}DashCase`]: dashCase(value),
+  [`${camelCase(optionsName)}PascalCase`]: pascalCase(value),
+  [`${camelCase(optionsName)}ProperCase`]: properCase(value),
+  [`${camelCase(optionsName)}LowerCase`]: value.toLowerCase(),
+  [`${optionsName}`]: value
+});
+var normalizeAllValues = (options) => {
+  let normalizedValues = {};
+  for (const key in options) {
+    if (Object.prototype.hasOwnProperty.call(options, key)) {
+      const element = options[key];
+      const newOptions = typeof element !== "string" || element === "" ? { [key]: element } : normalizeValue(key, element);
+      normalizedValues = {
+        ...normalizedValues,
+        ...newOptions
+      };
+    }
+  }
+  return normalizedValues;
+};
+
+// ../kos-codegen-core/src/lib/template-resolver.ts
+import * as path4 from "path";
+import * as fs4 from "fs";
+function findPackageRoot() {
+  if (process.env.KOS_TEMPLATE_BASE_DIR) {
+    return process.env.KOS_TEMPLATE_BASE_DIR;
+  }
+  let dir = __dirname;
+  while (dir !== path4.dirname(dir)) {
+    const pkgPath = path4.join(dir, "package.json");
+    if (fs4.existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(fs4.readFileSync(pkgPath, "utf-8"));
+        if (pkg.name === "@kosdev-code/kos-codegen-core") {
+          return dir;
+        }
+      } catch {
+      }
+    }
+    dir = path4.dirname(dir);
+  }
+  return path4.resolve(__dirname, "..", "..");
+}
+function getTemplateDir(generatorName) {
+  return path4.join(findPackageRoot(), "templates", generatorName);
+}
+
+// ../kos-codegen-core/src/lib/generators/generate-splash-project.ts
+import * as path5 from "path";
+function generateSplashProject(codegenFs, templateDir, options) {
+  const normalized = normalizeAllValues(options);
+  const projectRoot = `splash/${normalized.nameDashCase}`;
+  const toolsRoot = path5.join("tools", "scripts");
+  generateFilesFromTemplates(
+    codegenFs,
+    path5.join(templateDir, "project"),
+    projectRoot,
+    normalized
+  );
+  generateFilesFromTemplates(
+    codegenFs,
+    path5.join(templateDir, "tools"),
+    toolsRoot,
+    normalized
+  );
+}
+
+// ../kos-codegen-core/src/lib/generators/update-model-index.ts
+import * as ts from "typescript";
+
+// ../kos-codegen-core/src/lib/generators/component/types.ts
+var PLUGIN_TYPES = {
+  CUI: "cui",
+  UTILITY: "utility",
+  TROUBLE_ACTION: "troubleAction",
+  SETUP: "setup",
+  SETTING: "setting",
+  NAV: "nav",
+  CONTROL_POUR: "controlPour",
+  CUSTOM: "custom"
+};
+var CONTRIBUTION_TYPE_MAP = {
+  [PLUGIN_TYPES.SETUP]: "setup",
+  [PLUGIN_TYPES.CUI]: "cui",
+  [PLUGIN_TYPES.UTILITY]: "utility",
+  [PLUGIN_TYPES.SETTING]: "setting",
+  [PLUGIN_TYPES.NAV]: "nav",
+  [PLUGIN_TYPES.TROUBLE_ACTION]: "trouble-action",
+  [PLUGIN_TYPES.CONTROL_POUR]: "control-pour",
+  [PLUGIN_TYPES.CUSTOM]: "custom"
+};
+var LOCALIZED_PLUGIN_TYPES = /* @__PURE__ */ new Set([
+  PLUGIN_TYPES.CUI,
+  PLUGIN_TYPES.UTILITY,
+  PLUGIN_TYPES.SETUP,
+  PLUGIN_TYPES.SETTING,
+  PLUGIN_TYPES.NAV,
+  PLUGIN_TYPES.CONTROL_POUR,
+  PLUGIN_TYPES.TROUBLE_ACTION,
+  PLUGIN_TYPES.CUSTOM
+]);
+
+// ../kos-codegen-core/src/lib/generators/component/plugin-handlers/base.ts
+var BasePluginHandler = class {
+  getContributionKey() {
+    return this.contributionKey;
+  }
+  requiresLocalization() {
+    return this.requiresI18n;
+  }
+  getTemplatePath() {
+    return this.contributionKey;
+  }
+  /**
+   * Helper to create experience configuration
+   */
+  createExperience(options, experienceId) {
+    const compPath = this.getComponentPath(options);
+    return {
+      id: experienceId,
+      component: options.namePascalCase,
+      location: `./src/${compPath}`
+    };
+  }
+  /**
+   * Helper to get component path
+   */
+  getComponentPath(options) {
+    return `${options.appDirectory}/${this.contributionKey}/${options.nameDashCase}/${options.nameDashCase}.tsx`;
+  }
+  /**
+   * Helper to create config prefix
+   */
+  getConfigPrefix(options) {
+    return `${options.appProject}.${options.nameCamelCase}`;
+  }
+};
+
+// ../kos-codegen-core/src/lib/generators/component/plugin-handlers/control-pour-handler.ts
+var ControlPourPluginHandler = class extends BasePluginHandler {
+  pluginType = PLUGIN_TYPES.CONTROL_POUR;
+  contributionKey = "control-pour";
+  requiresI18n = true;
+  createConfiguration(options) {
+    const configPrefix = this.getConfigPrefix(options);
+    const experienceId = `${configPrefix}.controlPour.experience`;
+    const contribution = {
+      id: `${configPrefix}.controlPour`,
+      title: `${configPrefix}.controlPour.title`,
+      namespace: options.appProject,
+      experienceId
+    };
+    const experience = this.createExperience(options, experienceId);
+    return {
+      contributions: {
+        controlPour: [contribution]
+      },
+      experiences: {
+        [experienceId]: experience
+      }
+    };
+  }
+};
+
+// ../kos-codegen-core/src/lib/generators/component/plugin-handlers/cui-handler.ts
+var CuiPluginHandler = class extends BasePluginHandler {
+  pluginType = PLUGIN_TYPES.CUI;
+  contributionKey = "cui";
+  requiresI18n = true;
+  createConfiguration(options) {
+    const configPrefix = this.getConfigPrefix(options);
+    const experienceId = `${configPrefix}.cui.experience`;
+    const contribution = {
+      id: configPrefix,
+      title: `${configPrefix}.cui.title`,
+      namespace: options.appProject,
+      experienceId
+    };
+    const experience = this.createExperience(options, experienceId);
+    return {
+      contributions: {
+        cui: [contribution]
+      },
+      experiences: {
+        [experienceId]: experience
+      }
+    };
+  }
+};
+
+// ../kos-codegen-core/src/lib/generators/component/plugin-handlers/custom-handler.ts
+var CustomPluginHandler = class extends BasePluginHandler {
+  pluginType = PLUGIN_TYPES.CUSTOM;
+  contributionKey = "custom";
+  requiresI18n = true;
+  createConfiguration(options) {
+    const configPrefix = this.getConfigPrefix(options);
+    const experienceId = `${configPrefix}.${options.contributionKey || "custom"}.experience`;
+    const userContributionKey = options.contributionKey || "custom";
+    const contribution = {
+      id: configPrefix,
+      title: `${configPrefix}.${userContributionKey}.title`,
+      namespace: options.appProject,
+      experienceId
+      // TODO: Add additional fields as required by the plugin-explorer specification
+      // Refer to the plugin-explorer documentation for your specific contribution type
+    };
+    const experience = this.createExperience(options, experienceId);
+    return {
+      contributions: {
+        [userContributionKey]: [contribution]
+      },
+      experiences: {
+        [experienceId]: experience
+      }
+    };
+  }
+  getTemplatePath() {
+    return this.contributionKey || "custom";
+  }
+  getComponentPath(options) {
+    const pathKey = options.contributionKey || "custom";
+    return `${options.appDirectory}/${pathKey}/${options.nameDashCase}/${options.nameDashCase}.tsx`;
+  }
+};
+
+// ../kos-codegen-core/src/lib/generators/component/plugin-handlers/default-handler.ts
+var DefaultComponentHandler = class extends BasePluginHandler {
+  pluginType = "component";
+  contributionKey = "components";
+  requiresI18n = false;
+  createConfiguration(options) {
+    const compPath = this.getComponentPath(options);
+    const viewConfig = {
+      id: `${options.appProject}.${options.nameCamelCase}`,
+      title: "ddk.ncui.config.title",
+      namespace: options.appProject,
+      component: options.namePascalCase,
+      location: `./src/${compPath}`
+    };
+    return {
+      contributions: {},
+      experiences: {},
+      views: {
+        [this.getTabViewKey()]: [viewConfig]
+      }
+    };
+  }
+  getTabViewKey() {
+    return "ddk.ncui.settings.tabView";
+  }
+  getTemplatePath() {
+    return "files";
+  }
+};
+
+// ../kos-codegen-core/src/lib/generators/component/plugin-handlers/nav-handler.ts
+var NavPluginHandler = class extends BasePluginHandler {
+  pluginType = PLUGIN_TYPES.NAV;
+  contributionKey = "nav";
+  requiresI18n = true;
+  createConfiguration(options) {
+    const configPrefix = this.getConfigPrefix(options);
+    const experienceId = `${configPrefix}.nav.experience`;
+    const contribution = {
+      id: `${configPrefix}.nav`,
+      title: `${configPrefix}.nav.title`,
+      namespace: options.appProject,
+      navDescriptor: options.nameLowerCase,
+      experienceId
+    };
+    const experience = this.createExperience(options, experienceId);
+    return {
+      contributions: {
+        navViews: [contribution]
+      },
+      experiences: {
+        [experienceId]: experience
+      }
+    };
+  }
+};
+
+// ../kos-codegen-core/src/lib/generators/component/plugin-handlers/setting-handler.ts
+var SettingPluginHandler = class extends BasePluginHandler {
+  pluginType = PLUGIN_TYPES.SETTING;
+  contributionKey = "setting";
+  requiresI18n = true;
+  createConfiguration(options) {
+    const configPrefix = this.getConfigPrefix(options);
+    const experienceId = `${configPrefix}.settings.experience`;
+    const contribution = {
+      id: `${configPrefix}.setting`,
+      title: `${configPrefix}.setting.title`,
+      namespace: options.appProject,
+      settingsGroup: options.group || "general",
+      experienceId
+    };
+    const experience = this.createExperience(options, experienceId);
+    return {
+      contributions: {
+        settings: [contribution]
+      },
+      experiences: {
+        [experienceId]: experience
+      }
+    };
+  }
+};
+
+// ../kos-codegen-core/src/lib/generators/component/plugin-handlers/setup-handler.ts
+var SetupPluginHandler = class extends BasePluginHandler {
+  pluginType = PLUGIN_TYPES.SETUP;
+  contributionKey = "setup";
+  requiresI18n = true;
+  createConfiguration(options) {
+    const configPrefix = this.getConfigPrefix(options);
+    const experienceId = `${configPrefix}.setup.experience`;
+    const contribution = {
+      id: `${configPrefix}.setup`,
+      title: `${configPrefix}.setup.title`,
+      namespace: options.appProject,
+      setupDescriptor: options.nameCamelCase,
+      experienceId
+    };
+    const experience = this.createExperience(options, experienceId);
+    return {
+      contributions: {
+        setupStep: [contribution]
+      },
+      experiences: {
+        [experienceId]: experience
+      }
+    };
+  }
+};
+
+// ../kos-codegen-core/src/lib/generators/component/plugin-handlers/trouble-action-handler.ts
+var TroubleActionPluginHandler = class extends BasePluginHandler {
+  pluginType = PLUGIN_TYPES.TROUBLE_ACTION;
+  contributionKey = "trouble-action";
+  requiresI18n = true;
+  createConfiguration(options) {
+    const configPrefix = this.getConfigPrefix(options);
+    const experienceId = `${configPrefix}.troubleAction.experience`;
+    const contribution = {
+      id: `${configPrefix}.troubleAction`,
+      title: `${configPrefix}.troubleAction.title`,
+      namespace: options.appProject,
+      troubleType: options.nameCamelCase,
+      experienceId
+    };
+    const experience = this.createExperience(options, experienceId);
+    return {
+      contributions: {
+        troubleActions: [contribution]
+      },
+      experiences: {
+        [experienceId]: experience
+      }
+    };
+  }
+};
+
+// ../kos-codegen-core/src/lib/generators/component/plugin-handlers/utility-handler.ts
+var UtilityPluginHandler = class extends BasePluginHandler {
+  pluginType = PLUGIN_TYPES.UTILITY;
+  contributionKey = "utility";
+  requiresI18n = true;
+  createConfiguration(options) {
+    const configPrefix = this.getConfigPrefix(options);
+    const experienceId = `${configPrefix}.util.experience`;
+    const contribution = {
+      id: `${configPrefix}.util`,
+      title: `${configPrefix}.utility.title`,
+      namespace: options.appProject,
+      utilDescriptor: options.nameCamelCase,
+      experienceId
+    };
+    const experience = this.createExperience(options, experienceId);
+    return {
+      contributions: {
+        utilities: [contribution]
+      },
+      experiences: {
+        [experienceId]: experience
+      }
+    };
+  }
+};
+
+// ../kos-codegen-core/src/lib/generators/component/plugin-handlers/factory.ts
+var PluginHandlerFactory = class {
+  static handlers = /* @__PURE__ */ new Map([
+    [PLUGIN_TYPES.CUI, CuiPluginHandler],
+    [PLUGIN_TYPES.UTILITY, UtilityPluginHandler],
+    [PLUGIN_TYPES.SETTING, SettingPluginHandler],
+    [PLUGIN_TYPES.SETUP, SetupPluginHandler],
+    [PLUGIN_TYPES.NAV, NavPluginHandler],
+    [PLUGIN_TYPES.CONTROL_POUR, ControlPourPluginHandler],
+    [PLUGIN_TYPES.TROUBLE_ACTION, TroubleActionPluginHandler],
+    [PLUGIN_TYPES.CUSTOM, CustomPluginHandler]
+  ]);
+  static createHandler(pluginType) {
+    if (!pluginType) {
+      return new DefaultComponentHandler();
+    }
+    const HandlerClass = this.handlers.get(pluginType);
+    if (!HandlerClass) {
+      console.warn(
+        `No handler found for plugin type: ${pluginType}. Using default handler.`
+      );
+      return new DefaultComponentHandler();
+    }
+    return new HandlerClass();
+  }
+  static isValidPluginType(type) {
+    return this.handlers.has(type);
+  }
+};
+
+// src/lib/utils/action-factory.mjs
+var actionFactory = (action, metadata2) => {
+  return () => {
+    const _actions = [{ type: action }];
+    if (metadata2.invalidateCache) {
+      _actions.push({ type: "clearCache" });
     }
+    return _actions;
+  };
+};
+
+// src/lib/utils/validators.mjs
+function required(value) {
+  return value && value.trim() !== "" ? true : "This field is required.";
+}
 
+// src/lib/generators/project/splash.mjs
+var metadata = {
+  key: "project:splash",
+  name: "KOS Splash Screen Project",
+  invalidateCache: true,
+  namedArguments: { name: "name" }
+};
+async function splash_default(plop) {
+  plop.setActionType("createSplashProject", async function(answers) {
+    const cwd = process.cwd();
+    const codegenFs = new TrackingFileSystem(new DirectFileSystem(cwd));
+    generateSplashProject(codegenFs, getTemplateDir("kos-splash-project"), {
+      name: answers.name
+    });
+    await formatFiles(codegenFs.root, codegenFs.writtenPaths);
     return `Splash page project ${answers.name} created.`;
   });
-
   plop.setGenerator("project:splash", {
     description: "Create a new KOS Splash Page Project",
     prompts: [
@@ -31,9 +696,14 @@ export default async function (plop) {
         type: "input",
         name: "name",
         message: "What is the name of the splash project?",
-        validate: required,
-      },
+        validate: required
+      }
     ],
-    actions: actionFactory("createSplashProject", metadata),
+    actions: actionFactory("createSplashProject", metadata)
   });
 }
+export {
+  splash_default as default,
+  metadata
+};
+//# sourceMappingURL=splash.mjs.map