@akanjs/cli 3.0.0-beta.3 → 3.0.0-beta.31

package/{index-by5gpp8x.js → index-hj6w4ka1.js}

@@ -25,12 +25,13 @@ var scanRecipes2 = (sources) => {
         const parsed = parseRecipeCall(declaration.initializer);
         if (!parsed)
           continue;
+        const doc = getLeadingDoc(source.content, statement);
         recipes.push({
           name: declaration.name.text,
           importFrom: source.importFrom,
           variants: parsed.variants,
           ...parsed.defaultVariants ? { defaultVariants: parsed.defaultVariants } : {},
-          ...getLeadingDoc(source.content, statement) ? { doc: getLeadingDoc(source.content, statement) } : {},
+          ...doc ? { doc } : {},
           ...parsed.base ? { base: parsed.base } : {}
         });
       }

package/{index-j9yhg404.js → index-ksq4t16z.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   AppInfo
-} from "./index-2tv3fdx4.js";
+} from "./index-e52z7psd.js";
 
 // pkgs/@akanjs/devkit/slicePlanner.ts
 class SlicePlanner {
@@ -65,9 +65,6 @@ class SlicePlanner {
   constructor(app) {
     this.#app = app;
   }
-  async#trackedFiles(paths) {
-    return await this.#app.workspace.listGitFiles(paths);
-  }
   async#untrackedFiles(paths) {
     const [tracked, all] = await Promise.all([
       this.#app.workspace.listGitFiles(paths),
@@ -102,12 +99,12 @@ class SlicePlanner {
     const libs = appInfo.getLibs();
     const slicePaths = [`apps/${this.#app.name}`, ...libs.map((lib) => `libs/${lib}`)];
     const [appFiles, allTracked, untracked, rootPackageJson] = await Promise.all([
-      this.#trackedFiles([`apps/${this.#app.name}`]),
-      this.#trackedFiles(["."]),
+      this.#app.workspace.listGitFiles([`apps/${this.#app.name}`]),
+      this.#app.workspace.listGitFiles(["."]),
       this.#untrackedFiles(slicePaths),
       this.#app.workspace.getPackageJson()
     ]);
-    const libFiles = Object.fromEntries(await Promise.all(libs.map(async (lib) => [lib, await this.#trackedFiles([`libs/${lib}`])])));
+    const libFiles = Object.fromEntries(await Promise.all(libs.map(async (lib) => [lib, await this.#app.workspace.listGitFiles([`libs/${lib}`])])));
     const rootFiles = allTracked.filter((file) => !this.#isMemberFile(file));
     const required = SlicePlanner.#requiredDependencies(appInfo);
     const {

package/index-nhhrjvk1.js

@@ -0,0 +1,187 @@
+// @bun
+import {
+  runner,
+  script
+} from "./index-1skctzbq.js";
+import {
+  ModuleExecutor
+} from "./index-e52z7psd.js";
+import {
+  sourceFile,
+  moduleSourcePaths,
+  generatedFilesForSync,
+  createPassedPrimitiveReport,
+  bilingualLabelForField,
+  bilingualDescriptionForField
+} from "./index-84r80zdx.js";
+import {
+  PageScript
+} from "./index-qk9vv9hm.js";
+import {
+  pluralizeName
+} from "./index-nz8prx9g.js";
+
+// pkgs/@akanjs/cli/module/module.script.ts
+import { capitalize as capitalize2 } from "akanjs/common";
+
+// pkgs/@akanjs/cli/module/module.runner.ts
+import { capitalize } from "akanjs/common";
+var purposeByModule = {
+  budget: "Budget represents planned or actual money allocated inside the app.",
+  project: "Project represents a project workspace or business initiative managed by the app.",
+  task: "Task represents work items that move through the app workflow."
+};
+var moduleAbstractContent = (moduleName, sharedGuards) => {
+  const title = capitalize(moduleName);
+  const noun = bilingualLabelForField(moduleName).en.toLowerCase();
+  const purpose = purposeByModule[moduleName] ?? `${title} represents ${noun} records managed by the app.`;
+  const writeRule = sharedGuards ? `Anyone may read a ${noun}; only an admin creates, updates or removes one.` : `Anyone may read a ${noun}; nobody creates, updates or removes one until the slice names a guard.`;
+  return `# ${moduleName} Abstract
+${purpose}
+
+## Rules
+- ${writeRule}
+- Removal is soft: a removed ${noun} keeps its row with \`removedAt\` set.
+`;
+};
+var moduleFileKeys = [
+  "abstract",
+  "constant",
+  "dictionary",
+  "service",
+  "store",
+  "signal",
+  "unit",
+  "view",
+  "template",
+  "zone",
+  "util"
+];
+
+class ModuleRunner extends runner("module") {
+  async createService(module) {
+    const serviceName = module.name.replace(/^_+/, "");
+    await module.applyTemplate({
+      basePath: `.`,
+      template: "service",
+      dict: { model: serviceName, sysName: module.sys.name }
+    });
+    return await this.#readFiles(module, {
+      abstract: `${serviceName}.abstract.md`,
+      dictionary: `${serviceName}.dictionary.ts`,
+      service: `${serviceName}.service.ts`,
+      signal: `${serviceName}.signal.ts`,
+      store: `${serviceName}.store.ts`
+    });
+  }
+  async#readFiles(module, filenames) {
+    const files = await Promise.all(Object.entries(filenames).map(async ([key, filename]) => [
+      key,
+      { filename, content: await module.readFile(filename) }
+    ]));
+    return Object.fromEntries(files);
+  }
+  async removeModule(module) {
+    await module.sys.removeDir(`lib/${module.name}`);
+  }
+  async#hasSharedGuards(module) {
+    const { sys } = module;
+    if (sys.type === "lib" && sys.name === "shared")
+      return true;
+    if (!await sys.exists("lib/srv.ts"))
+      return false;
+    return (await sys.readFile("lib/srv.ts")).includes('"@libs/shared/lib/srv"');
+  }
+  async createComponentTemplate(module, type) {
+    await module.sys.applyTemplate({
+      basePath: `./lib/${module.name}`,
+      template: `module/__Model__.${capitalize(type)}.tsx`,
+      dict: { model: module.name, sysName: module.sys.name, sysType: module.sys.type }
+    });
+    return {
+      component: {
+        filename: `${capitalize(module.name)}.${capitalize(type)}.tsx`,
+        content: await module.sys.readFile(`lib/${module.name}/${capitalize(module.name)}.${capitalize(type)}.tsx`)
+      }
+    };
+  }
+  async createModuleTemplate(module) {
+    const names = pluralizeName(module.name);
+    const modelLabel = bilingualLabelForField(module.name);
+    const modelDescription = bilingualDescriptionForField(module.name);
+    const paths = moduleSourcePaths(module.name);
+    const filenames = Object.fromEntries(moduleFileKeys.map((key) => [key, paths[key].replace(`lib/${module.name}/`, "")]));
+    const sharedGuards = await this.#hasSharedGuards(module);
+    await module.applyTemplate({
+      basePath: `.`,
+      template: "module",
+      options: { sharedGuards },
+      dict: {
+        model: module.name,
+        models: names,
+        sysName: module.sys.name,
+        sysType: module.sys.type,
+        modelLabelEn: modelLabel.en,
+        modelLabelKo: modelLabel.ko,
+        modelDescEn: modelDescription.en,
+        modelDescKo: modelDescription.ko
+      }
+    });
+    await module.writeFile(filenames.abstract, moduleAbstractContent(module.name, sharedGuards));
+    return await this.#readFiles(module, filenames);
+  }
+}
+
+// pkgs/@akanjs/cli/module/module.script.ts
+var moduleChangedFiles = (sys, moduleName, files) => Object.values(files).map((file) => sourceFile(sys, `lib/${moduleName}/${file.filename}`, "create", "Module source file was created."));
+
+class ModuleScript extends script("module", [ModuleRunner, PageScript]) {
+  async createModuleTemplate(sys, name, { page = false } = {}) {
+    const mod = ModuleExecutor.from(sys, name);
+    const files = await this.moduleRunner.createModuleTemplate(mod);
+    if (page && sys.type === "app")
+      await this.pageScript.createCrudPage(mod, { app: sys, basePath: null, single: false });
+    await sys.scan();
+    return createPassedPrimitiveReport({
+      command: "create-module",
+      changedFiles: moduleChangedFiles(sys, name, files),
+      generatedFiles: generatedFilesForSync(sys, "Generated files were refreshed after module creation."),
+      target: sys.name
+    });
+  }
+  async removeModule(mod) {
+    await this.moduleRunner.removeModule(mod);
+  }
+  async createService(sys, name) {
+    const service = ModuleExecutor.from(sys, `_${name}`);
+    const files = await this.moduleRunner.createService(service);
+    await sys.scan();
+    return createPassedPrimitiveReport({
+      command: "create-service",
+      changedFiles: moduleChangedFiles(sys, `_${name}`, files),
+      generatedFiles: generatedFilesForSync(sys, "Generated files were refreshed after service creation."),
+      target: sys.name
+    });
+  }
+  async createTemplate(mod) {
+    return await this.#createComponent(mod, "template");
+  }
+  async createUnit(mod) {
+    return await this.#createComponent(mod, "unit");
+  }
+  async createView(mod) {
+    return await this.#createComponent(mod, "view");
+  }
+  async#createComponent(mod, type) {
+    const { component } = await this.moduleRunner.createComponentTemplate(mod, type);
+    return createPassedPrimitiveReport({
+      command: `create-${type}`,
+      changedFiles: [
+        sourceFile(mod.sys, `lib/${mod.name}/${component.filename}`, "create", `${capitalize2(type)} UI source was created.`)
+      ],
+      target: mod.sys.name
+    });
+  }
+}
+
+export { ModuleScript };

package/index-p6pbz9n5.js

@@ -0,0 +1,25 @@
+// @bun
+// pkgs/@akanjs/cli/clipboard.ts
+var clipboardCommands = () => {
+  if (process.platform === "darwin")
+    return [["pbcopy"]];
+  if (process.platform === "win32")
+    return [["clip"]];
+  return [["wl-copy"], ["xclip", "-selection", "clipboard"], ["xsel", "--clipboard", "--input"]];
+};
+var writeClipboard = async (text) => {
+  for (const command of clipboardCommands()) {
+    try {
+      const proc = Bun.spawn(command, {
+        stdin: new TextEncoder().encode(text),
+        stdout: "ignore",
+        stderr: "ignore"
+      });
+      if (await proc.exited === 0)
+        return true;
+    } catch {}
+  }
+  return false;
+};
+
+export { writeClipboard };