@flowgram.ai/cli 0.1.8

package/bin/index.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../dist/index.js';

package/dist/index.cjs

@@ -0,0 +1,493 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../common/temp/node_modules/.pnpm/tsup@8.3.5_typescript@5.8.3/node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.src || new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+
+// src/index.ts
+var import_commander = require("commander");
+
+// src/materials/index.ts
+var import_inquirer = __toESM(require("inquirer"), 1);
+var import_chalk2 = __toESM(require("chalk"), 1);
+
+// src/materials/materials.ts
+var import_url = require("url");
+var import_path2 = __toESM(require("path"), 1);
+var import_fs2 = __toESM(require("fs"), 1);
+
+// src/utils/traverse-file.ts
+var import_path = __toESM(require("path"), 1);
+var import_fs = __toESM(require("fs"), 1);
+var File = class {
+  constructor(filePath, root = "/") {
+    this.root = root;
+    this.path = filePath;
+    this.relativePath = import_path.default.relative(this.root, this.path);
+    this.suffix = import_path.default.extname(this.path);
+    if (!import_fs.default.existsSync(this.path)) {
+      throw Error(`File ${import_path.default} Not Exists`);
+    }
+    try {
+      this.content = import_fs.default.readFileSync(this.path, "utf-8");
+      this.isUtf8 = true;
+    } catch (e) {
+      this.isUtf8 = false;
+      return;
+    }
+  }
+  replace(updater) {
+    if (!this.isUtf8) {
+      console.warn("Not UTF-8 file skipped: ", this.path);
+      return;
+    }
+    this.content = updater(this.content);
+    import_fs.default.writeFileSync(this.path, this.content, "utf-8");
+  }
+};
+function* traverseRecursiveFiles(folder) {
+  const files = import_fs.default.readdirSync(folder);
+  for (const file of files) {
+    const filePath = import_path.default.join(folder, file);
+    if (import_fs.default.statSync(filePath).isDirectory()) {
+      yield* traverseRecursiveFiles(filePath);
+    } else {
+      yield new File(filePath);
+    }
+  }
+}
+
+// src/utils/import.ts
+function assembleImport(declaration) {
+  const { namedImports, defaultImport, namespaceImport, source } = declaration;
+  const importClauses = [];
+  if (namedImports) {
+    importClauses.push(
+      `{ ${namedImports.map(
+        ({ local, imported, typeOnly }) => `${typeOnly ? "type " : ""}${imported}${local ? ` as ${local}` : ""}`
+      ).join(", ")} }`
+    );
+  }
+  if (defaultImport) {
+    importClauses.push(defaultImport);
+  }
+  if (namespaceImport) {
+    importClauses.push(`* as ${namespaceImport}`);
+  }
+  return `import ${importClauses.join(", ")} from '${source}'`;
+}
+function replaceImport(fileContent, origin, replaceTo) {
+  const replaceImportStatements = replaceTo.map(assembleImport);
+  return fileContent.replace(origin.statement, replaceImportStatements.join("\n"));
+}
+function* traverseFileImports(fileContent) {
+  const importRegex = /import\s+([^{}*,]*?)?(?:\s*\*\s*as\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*,?)?(?:\s*\{([^}]*)\}\s*,?)?(?:\s*([a-zA-Z_$][a-zA-Z0-9_$]*)\s*,?)?\s*from\s*['"`]([^'"`]+)['"`]/g;
+  let match;
+  while ((match = importRegex.exec(fileContent)) !== null) {
+    const [fullMatch, defaultPart, namespacePart, namedPart, defaultPart2, source] = match;
+    const declaration = {
+      statement: fullMatch,
+      source
+    };
+    const defaultImport = defaultPart?.trim() || defaultPart2?.trim();
+    if (defaultImport && !namespacePart && !namedPart) {
+      declaration.defaultImport = defaultImport;
+    } else if (defaultImport && (namespacePart || namedPart)) {
+      declaration.defaultImport = defaultImport;
+    }
+    if (namespacePart) {
+      declaration.namespaceImport = namespacePart.trim();
+    }
+    if (namedPart) {
+      const namedImports = [];
+      const namedItems = namedPart.split(",").map((item) => item.trim()).filter(Boolean);
+      for (const item of namedItems) {
+        const typeOnly = item.startsWith("type ");
+        const cleanItem = typeOnly ? item.slice(5).trim() : item;
+        if (cleanItem.includes(" as ")) {
+          const [imported, local] = cleanItem.split(" as ").map((s) => s.trim());
+          namedImports.push({
+            imported,
+            local,
+            typeOnly
+          });
+        } else {
+          namedImports.push({
+            imported: cleanItem,
+            typeOnly
+          });
+        }
+      }
+      if (namedImports.length > 0) {
+        declaration.namedImports = namedImports;
+      }
+    }
+    yield declaration;
+  }
+}
+
+// src/materials/materials.ts
+var __filename2 = (0, import_url.fileURLToPath)(importMetaUrl);
+var __dirname2 = import_path2.default.dirname(__filename2);
+var _types = [
+  "components",
+  "effects",
+  "plugins",
+  "shared",
+  "typings",
+  "validate",
+  "form-plugins",
+  "hooks"
+];
+function listAllMaterials(formMaterialSrc) {
+  const _materials = [];
+  for (const _type of _types) {
+    const materialsPath = import_path2.default.join(formMaterialSrc, _type);
+    _materials.push(
+      ...import_fs2.default.readdirSync(materialsPath).map((_path) => {
+        if (_path === "index.ts") {
+          return null;
+        }
+        return {
+          name: _path,
+          // Assuming the folder name is the material name
+          type: _type,
+          path: import_path2.default.join(materialsPath, _path)
+        };
+      }).filter((material) => material !== null)
+    );
+  }
+  return _materials;
+}
+var getFormMaterialDependencies = (formMaterialPath) => {
+  const packageJsonPath = import_path2.default.join(formMaterialPath, "package.json");
+  const packageJson = JSON.parse(import_fs2.default.readFileSync(packageJsonPath, "utf8"));
+  return packageJson.dependencies;
+};
+var copyMaterial = (material, project, formMaterialPath) => {
+  const formMaterialDependencies = getFormMaterialDependencies(formMaterialPath);
+  const sourceDir = material.path;
+  const materialRoot = import_path2.default.join(
+    project.projectPath,
+    "src",
+    "form-materials",
+    `${material.type}`
+  );
+  const targetDir = import_path2.default.join(materialRoot, material.name);
+  const packagesToInstall = /* @__PURE__ */ new Set();
+  import_fs2.default.cpSync(sourceDir, targetDir, { recursive: true });
+  for (const file of traverseRecursiveFiles(targetDir)) {
+    if ([".ts", ".tsx"].includes(file.suffix)) {
+      for (const importDeclaration of traverseFileImports(file.content)) {
+        const { source } = importDeclaration;
+        if (source.startsWith("@/")) {
+          console.log(
+            `Replace Import from ${source} to @flowgram.ai/form-materials`
+          );
+          file.replace(
+            (content) => replaceImport(content, importDeclaration, [
+              { ...importDeclaration, source: "@flowgram.ai/form-materials" }
+            ])
+          );
+          packagesToInstall.add(
+            `@flowgram.ai/form-materials@${project.flowgramVersion}`
+          );
+        } else if (!source.startsWith(".") && !source.startsWith("react")) {
+          const [dep, version] = Object.entries(formMaterialDependencies).find(
+            ([_key]) => source.startsWith(_key)
+          ) || [];
+          if (!dep) {
+            continue;
+          }
+          if (dep.startsWith("@flowgram.ai/")) {
+            packagesToInstall.add(`${dep}@${project.flowgramVersion}`);
+          } else {
+            packagesToInstall.add(`${dep}@${version}`);
+          }
+        }
+      }
+    }
+  }
+  return {
+    packagesToInstall: [...packagesToInstall]
+  };
+};
+
+// src/utils/npm.ts
+var import_child_process = require("child_process");
+var import_fs3 = require("fs");
+var import_path3 = __toESM(require("path"), 1);
+var import_download = __toESM(require("download"), 1);
+async function getLatestVersion(packageName) {
+  return (0, import_child_process.execSync)(`npm view ${packageName} version --tag=latest`).toString().trim();
+}
+async function loadNpm(packageName) {
+  const packageLatestVersion = await getLatestVersion(packageName);
+  const packagePath = import_path3.default.join(
+    __dirname,
+    `./.download/${packageName}-${packageLatestVersion}`
+  );
+  if ((0, import_fs3.existsSync)(packagePath)) {
+    return packagePath;
+  }
+  try {
+    const tarballUrl = (0, import_child_process.execSync)(
+      `npm view ${packageName}@${packageLatestVersion} dist.tarball`
+    ).toString().trim();
+    await (0, import_download.default)(tarballUrl, packagePath, { extract: true, strip: 1 });
+    return packagePath;
+  } catch (error) {
+    console.error(`Error downloading or extracting package: ${error}`);
+    throw error;
+  }
+}
+
+// src/materials/index.ts
+var import_path5 = __toESM(require("path"), 1);
+
+// src/utils/project.ts
+var import_fs4 = require("fs");
+var import_path4 = __toESM(require("path"), 1);
+var import_chalk = __toESM(require("chalk"), 1);
+var Project = class _Project {
+  constructor() {
+  }
+  async init() {
+    let projectPath = process.cwd();
+    while (projectPath !== "/" && !(0, import_fs4.existsSync)(import_path4.default.join(projectPath, "package.json"))) {
+      projectPath = import_path4.default.join(projectPath, "..");
+    }
+    if (projectPath === "/") {
+      throw new Error("Please run this command in a valid project");
+    }
+    this.projectPath = projectPath;
+    this.packageJsonPath = import_path4.default.join(projectPath, "package.json");
+    this.packageJson = JSON.parse((0, import_fs4.readFileSync)(this.packageJsonPath, "utf8"));
+    this.flowgramVersion = this.packageJson.dependencies["@flowgram.ai/fixed-layout-editor"] || this.packageJson.dependencies["@flowgram.ai/free-layout-editor"] || this.packageJson.dependencies["@flowgram.ai/editor"];
+  }
+  async addDependency(dependency) {
+    let name;
+    let version;
+    const lastAtIndex = dependency.lastIndexOf("@");
+    if (lastAtIndex <= 0) {
+      name = dependency;
+      version = await getLatestVersion(name);
+    } else {
+      name = dependency.substring(0, lastAtIndex);
+      version = dependency.substring(lastAtIndex + 1);
+      if (!version.trim()) {
+        version = await getLatestVersion(name);
+      }
+    }
+    this.packageJson.dependencies[name] = version;
+    (0, import_fs4.writeFileSync)(
+      this.packageJsonPath,
+      JSON.stringify(this.packageJson, null, 2)
+    );
+  }
+  async addDependencies(dependencies) {
+    for (const dependency of dependencies) {
+      await this.addDependency(dependency);
+    }
+  }
+  printInfo() {
+    console.log(import_chalk.default.bold("Project Info:"));
+    console.log(import_chalk.default.black(`  - Flowgram Version: ${this.flowgramVersion}`));
+    console.log(import_chalk.default.black(`  - Project Path: ${this.projectPath}`));
+  }
+  static async getSingleton() {
+    const info = new _Project();
+    await info.init();
+    return info;
+  }
+};
+
+// src/materials/index.ts
+async function syncMaterial(materialName) {
+  console.log(import_chalk2.default.bgGreenBright("Welcome to @flowgram.ai form-materials!"));
+  const project = await Project.getSingleton();
+  project.printInfo();
+  if (!project.flowgramVersion) {
+    throw new Error(
+      "Please install @flowgram.ai/fixed-layout-editor or @flowgram.ai/free-layout-editor"
+    );
+  }
+  const formMaterialPath = await loadNpm("@flowgram.ai/form-materials");
+  const formMaterialSrc = import_path5.default.join(formMaterialPath, "src");
+  const materials = listAllMaterials(formMaterialSrc);
+  let material;
+  if (materialName) {
+    const selectedMaterial = materials.find(
+      (m) => `${m.type}/${m.name}` === materialName
+    );
+    if (selectedMaterial) {
+      material = selectedMaterial;
+      console.log(import_chalk2.default.green(`Using material: ${materialName}`));
+    } else {
+      console.log(
+        import_chalk2.default.yellow(
+          `Material "${materialName}" not found. Please select from the list:`
+        )
+      );
+    }
+  }
+  if (!material) {
+    const result = await import_inquirer.default.prompt([
+      {
+        type: "list",
+        name: "material",
+        message: "Select one material to add:",
+        choices: [
+          ...materials.map((_material) => ({
+            name: `${_material.type}/${_material.name}`,
+            value: _material
+          }))
+        ]
+      }
+    ]);
+    material = result.material;
+  }
+  if (!material) {
+    console.error(import_chalk2.default.red("No material selected. Exiting."));
+    process.exit(1);
+  }
+  console.log(
+    import_chalk2.default.bold("The following materials will be added to your project")
+  );
+  console.log(material);
+  let { packagesToInstall } = copyMaterial(material, project, formMaterialPath);
+  await project.addDependencies(packagesToInstall);
+  console.log(
+    import_chalk2.default.bold("These npm dependencies is added to your package.json")
+  );
+  packagesToInstall.forEach((_package) => {
+    console.log(`- ${_package}`);
+  });
+  console.log(import_chalk2.default.bold("\nPlease run npm install to install dependencies"));
+}
+
+// src/create-app/index.ts
+var import_path6 = __toESM(require("path"), 1);
+var import_child_process2 = require("child_process");
+var import_inquirer2 = __toESM(require("inquirer"), 1);
+var import_fs_extra = __toESM(require("fs-extra"), 1);
+var import_chalk3 = __toESM(require("chalk"), 1);
+var import_download2 = __toESM(require("download"), 1);
+var tar = __toESM(require("tar"), 1);
+var args = process.argv.slice(2);
+var updateFlowGramVersions = (dependencies, latestVersion) => {
+  for (const packageName in dependencies) {
+    if (packageName.startsWith("@flowgram.ai")) {
+      dependencies[packageName] = latestVersion;
+    }
+  }
+};
+var createApp = async (projectName) => {
+  console.log(import_chalk3.default.green("Welcome to @flowgram.ai/create-app CLI!"));
+  const latest = (0, import_child_process2.execSync)("npm view @flowgram.ai/demo-fixed-layout version --tag=latest latest").toString().trim();
+  let folderName = "";
+  if (!projectName) {
+    const { repo } = await import_inquirer2.default.prompt([
+      {
+        type: "list",
+        name: "repo",
+        message: "Select a demo to create:",
+        choices: [
+          { name: "Fixed Layout Demo", value: "demo-fixed-layout" },
+          { name: "Free Layout Demo", value: "demo-free-layout" },
+          { name: "Fixed Layout Demo Simple", value: "demo-fixed-layout-simple" },
+          { name: "Free Layout Demo Simple", value: "demo-free-layout-simple" },
+          { name: "Free Layout Nextjs Demo", value: "demo-nextjs" },
+          { name: "Free Layout Vite Demo Simple", value: "demo-vite" },
+          { name: "Demo Playground for infinite canvas", value: "demo-playground" }
+        ]
+      }
+    ]);
+    folderName = repo;
+  } else {
+    if (["fixed-layout", "free-layout", "fixed-layout-simple", "free-layout-simple", "playground", "nextjs"].includes(projectName)) {
+      folderName = `demo-${projectName}`;
+    } else {
+      console.error('Invalid projectName. Please run "npx create-app" to choose demo.');
+      return;
+    }
+  }
+  try {
+    const targetDir = import_path6.default.join(process.cwd());
+    const downloadPackage = async () => {
+      try {
+        const tarballBuffer = await (0, import_download2.default)(`https://registry.npmjs.org/@flowgram.ai/${folderName}/-/${folderName}-${latest}.tgz`);
+        import_fs_extra.default.ensureDirSync(targetDir);
+        const tempTarballPath = import_path6.default.join(process.cwd(), `${folderName}.tgz`);
+        import_fs_extra.default.writeFileSync(tempTarballPath, tarballBuffer);
+        await tar.x({
+          file: tempTarballPath,
+          C: targetDir
+        });
+        import_fs_extra.default.renameSync(import_path6.default.join(targetDir, "package"), import_path6.default.join(targetDir, folderName));
+        import_fs_extra.default.unlinkSync(tempTarballPath);
+        return true;
+      } catch (error) {
+        console.error(`Error downloading or extracting package: ${error}`);
+        return false;
+      }
+    };
+    const res = await downloadPackage();
+    const pkgJsonPath = import_path6.default.join(targetDir, folderName, "package.json");
+    const data = import_fs_extra.default.readFileSync(pkgJsonPath, "utf-8");
+    const packageLatestVersion = (0, import_child_process2.execSync)("npm view @flowgram.ai/core version --tag=latest latest").toString().trim();
+    const jsonData = JSON.parse(data);
+    if (jsonData.dependencies) {
+      updateFlowGramVersions(jsonData.dependencies, packageLatestVersion);
+    }
+    if (jsonData.devDependencies) {
+      updateFlowGramVersions(jsonData.devDependencies, packageLatestVersion);
+    }
+    import_fs_extra.default.writeFileSync(pkgJsonPath, JSON.stringify(jsonData, null, 2), "utf-8");
+    if (res) {
+      console.log(import_chalk3.default.green(`${folderName} Demo project created successfully!`));
+      console.log(import_chalk3.default.yellow("Run the following commands to start:"));
+      console.log(import_chalk3.default.cyan(`  cd ${folderName}`));
+      console.log(import_chalk3.default.cyan("  npm install"));
+      console.log(import_chalk3.default.cyan("  npm start"));
+    } else {
+      console.log(import_chalk3.default.red("Download failed"));
+    }
+  } catch (error) {
+    console.error("Error downloading repo:", error);
+    return;
+  }
+};
+
+// src/index.ts
+var program = new import_commander.Command();
+program.name("flowgram-cli").version("1.0.0").description("Flowgram CLI");
+program.command("create-app").description("Create a new flowgram project").argument("[string]", "Project name").action(async (projectName) => {
+  await createApp(projectName);
+});
+program.command("materials").description("Sync materials to the project").argument("[string]", "Material name").action(async (materialName) => {
+  await syncMaterial(materialName);
+});
+program.parse(process.argv);

package/dist/index.d.cts

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

package/dist/index.d.ts

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