@lazarv/create-react-server 0.0.0-experimental-d003259-20250211-2495688e

package/lib/code-merge.mjs

@@ -0,0 +1,246 @@
+import { Project, ts } from "ts-morph";
+
+import { format } from "./formatter.mjs";
+
+export async function mergeCodeFiles(...fileContents) {
+  const project = new Project({
+    useInMemoryFileSystem: true,
+    compilerOptions: {
+      allowJs: true,
+      checkJs: false,
+      esModuleInterop: true,
+    },
+  });
+
+  const mergedSourceFile = project.createSourceFile("mergedFile.ts", "", {
+    overwrite: true,
+  });
+
+  const importDeclarations = [];
+  const otherStatementsMap = new Map();
+
+  fileContents.forEach((content, index) => {
+    const sourceFile = project.createSourceFile(`file${index}.ts`, content, {
+      overwrite: true,
+    });
+
+    sourceFile.getImportDeclarations().forEach((importDecl) => {
+      importDeclarations.push(importDecl);
+    });
+
+    sourceFile.getStatements().forEach((stmt) => {
+      if (!stmt.isKind(ts.SyntaxKind.ImportDeclaration)) {
+        const key = getStatementKey(stmt);
+        if (!otherStatementsMap.has(key)) {
+          otherStatementsMap.set(key, stmt);
+        } else {
+          const existingStmt = otherStatementsMap.get(key);
+          mergeNodes(existingStmt, stmt);
+        }
+      }
+    });
+  });
+
+  const groupedImports = groupAndSortImports(importDeclarations);
+  groupedImports.forEach((importDecl) => {
+    mergedSourceFile.addImportDeclaration({
+      moduleSpecifier: importDecl.getModuleSpecifierValue(),
+      defaultImport: importDecl.getDefaultImport()?.getText(),
+      namedImports: importDecl.getNamedImports().map((ni) => ni.getText()),
+    });
+  });
+
+  otherStatementsMap.forEach((stmt) => {
+    mergedSourceFile.addStatements(stmt.getFullText());
+  });
+
+  const mergedCode = mergedSourceFile.getFullText();
+  return format(mergedCode, "typescript");
+}
+
+function getStatementKey(stmt) {
+  if (stmt.isKind(ts.SyntaxKind.VariableStatement)) {
+    const declarations = stmt.getDeclarationList().getDeclarations();
+    return declarations.map((decl) => decl.getName()).join(",");
+  } else if (stmt.isKind(ts.SyntaxKind.FunctionDeclaration)) {
+    return `Function:${stmt.getName()}`;
+  } else if (stmt.isKind(ts.SyntaxKind.ClassDeclaration)) {
+    return `Class:${stmt.getName()}`;
+  } else if (stmt.isKind(ts.SyntaxKind.ExpressionStatement)) {
+    const expression = stmt.getExpression();
+    return `Expression:${expression.getText()}`;
+  } else if (stmt.isKind(ts.SyntaxKind.ExportAssignment)) {
+    return `ExportAssignment`;
+  }
+  return `Kind:${stmt.getKindName()}:${stmt.getText()}`;
+}
+
+function mergeNodes(target, source) {
+  if (
+    ts.isObjectLiteralExpression(target.compilerNode) &&
+    ts.isObjectLiteralExpression(source.compilerNode)
+  ) {
+    mergeObjectLiterals(target, source);
+  } else if (target.getChildCount() > 0 && source.getChildCount() > 0) {
+    const targetChildren = target.getChildren();
+    const sourceChildren = source.getChildren();
+    const length = Math.max(targetChildren.length, sourceChildren.length);
+
+    for (let i = 0; i < length; i++) {
+      const targetChild = targetChildren[i];
+      const sourceChild = sourceChildren[i];
+
+      if (targetChild && sourceChild) {
+        mergeNodes(targetChild, sourceChild);
+      } else if (sourceChild) {
+        target.addChildText(sourceChild.getFullText());
+      }
+    }
+  } else {
+    target.replaceWithText(source.getFullText());
+  }
+}
+
+function mergeObjectLiterals(target, source) {
+  const targetProperties = target.getProperties();
+  const sourceProperties = source.getProperties();
+
+  const targetPropertyMap = new Map();
+  targetProperties.forEach((prop) => {
+    const name = prop.getName();
+    if (name) {
+      targetPropertyMap.set(name, prop);
+    }
+  });
+
+  sourceProperties.forEach((sourceProp) => {
+    const name = sourceProp.getName();
+    if (name) {
+      const targetProp = targetPropertyMap.get(name);
+
+      if (targetProp) {
+        const targetInitializer = getInitializer(targetProp);
+        const sourceInitializer = getInitializer(sourceProp);
+
+        if (
+          targetInitializer &&
+          sourceInitializer &&
+          ts.isObjectLiteralExpression(targetInitializer.compilerNode) &&
+          ts.isObjectLiteralExpression(sourceInitializer.compilerNode)
+        ) {
+          mergeObjectLiterals(targetInitializer, sourceInitializer);
+        } else if (
+          targetInitializer &&
+          sourceInitializer &&
+          ts.isArrayLiteralExpression(targetInitializer.compilerNode) &&
+          ts.isArrayLiteralExpression(sourceInitializer.compilerNode)
+        ) {
+          mergeArrays(targetInitializer, sourceInitializer);
+        } else {
+          targetProp.replaceWithText(sourceProp.getFullText());
+        }
+      } else {
+        target.addProperty(sourceProp.getFullText());
+      }
+    } else {
+      target.addProperty(sourceProp.getFullText());
+    }
+  });
+}
+
+function mergeArrays(targetArray, sourceArray) {
+  const targetElements = targetArray.getElements();
+  const sourceElements = sourceArray.getElements();
+
+  const targetTexts = targetElements.map((el) => el.getText());
+  const sourceTexts = sourceElements.map((el) => el.getText());
+
+  const mergedTexts = [...targetTexts, ...sourceTexts];
+
+  const mergedArrayText = `[${mergedTexts.join(", ")}]`;
+  targetArray.replaceWithText(mergedArrayText);
+}
+
+function getInitializer(prop) {
+  if (prop.isKind(ts.SyntaxKind.PropertyAssignment)) {
+    return prop.getInitializer();
+  } else if (prop.isKind(ts.SyntaxKind.ShorthandPropertyAssignment)) {
+    return prop.getNameNode();
+  } else if (prop.isKind(ts.SyntaxKind.MethodDeclaration)) {
+    return prop;
+  }
+  return null;
+}
+
+function groupAndSortImports(importDeclarations) {
+  const externalImports = [];
+  const builtInImports = [];
+  const relativeImports = [];
+
+  const importMap = new Map();
+
+  importDeclarations.forEach((importDecl) => {
+    const moduleSpecifier = importDecl.getModuleSpecifierValue();
+    const importKey = moduleSpecifier;
+
+    if (importMap.has(importKey)) {
+      const existingImport = importMap.get(importKey);
+      mergeImportDeclarations(existingImport, importDecl);
+    } else {
+      importMap.set(importKey, importDecl);
+
+      if (isRelativeImport(moduleSpecifier)) {
+        relativeImports.push(importDecl);
+      } else if (isBuiltInImport(moduleSpecifier)) {
+        builtInImports.push(importDecl);
+      } else {
+        externalImports.push(importDecl);
+      }
+    }
+  });
+
+  builtInImports.sort(compareModuleSpecifiers);
+  externalImports.sort(compareModuleSpecifiers);
+  relativeImports.sort(compareModuleSpecifiers);
+
+  return [...builtInImports, ...externalImports, ...relativeImports];
+}
+
+function isRelativeImport(moduleSpecifier) {
+  return (
+    moduleSpecifier.startsWith("./") ||
+    moduleSpecifier.startsWith("../") ||
+    moduleSpecifier === "." ||
+    moduleSpecifier === ".."
+  );
+}
+
+function isBuiltInImport(moduleSpecifier) {
+  return moduleSpecifier.startsWith("node:");
+}
+
+function compareModuleSpecifiers(a, b) {
+  const specA = a.getModuleSpecifierValue();
+  const specB = b.getModuleSpecifierValue();
+  return specA.localeCompare(specB);
+}
+
+function mergeImportDeclarations(targetImport, sourceImport) {
+  const targetNamedImports = new Set(
+    targetImport.getNamedImports().map((ni) => ni.getText())
+  );
+  sourceImport.getNamedImports().forEach((ni) => {
+    const name = ni.getText();
+    if (!targetNamedImports.has(name)) {
+      targetImport.addNamedImport(name);
+      targetNamedImports.add(name);
+    }
+  });
+
+  const targetDefaultImport = targetImport.getDefaultImport()?.getText();
+  const sourceDefaultImport = sourceImport.getDefaultImport()?.getText();
+
+  if (!targetDefaultImport && sourceDefaultImport) {
+    targetImport.setDefaultImport(sourceDefaultImport);
+  }
+}

package/lib/dynamic-checkbox.mjs

@@ -0,0 +1,259 @@
+import {
+  createPrompt,
+  isDownKey,
+  isEnterKey,
+  isNumberKey,
+  isSpaceKey,
+  isUpKey,
+  makeTheme,
+  Separator,
+  useKeypress,
+  useMemo,
+  usePagination,
+  usePrefix,
+  useRef,
+  useState,
+  ValidationError,
+} from "@inquirer/core";
+import figures from "@inquirer/figures";
+import ansiEscapes from "ansi-escapes";
+import colors from "picocolors";
+
+const checkboxTheme = {
+  icon: {
+    checked: colors.green(figures.circleFilled),
+    unchecked: figures.circle,
+    cursor: figures.pointer,
+  },
+  style: {
+    disabledChoice: (text) => colors.dim(`- ${text}`),
+    renderSelectedChoices: (selectedChoices) =>
+      selectedChoices.map((choice) => choice.short).join(", "),
+    description: (text) => colors.cyan(text),
+  },
+  helpMode: "auto",
+};
+
+function isSelectable(item) {
+  return !Separator.isSeparator(item) && !item.disabled;
+}
+
+function isChecked(item) {
+  return isSelectable(item) && Boolean(item.checked);
+}
+
+function toggle(item) {
+  return isSelectable(item) ? { ...item, checked: !item.checked } : item;
+}
+
+function check(checked) {
+  return function (item) {
+    return isSelectable(item) ? { ...item, checked } : item;
+  };
+}
+
+function normalizeChoices(choices) {
+  return choices.map((choice) => {
+    if (Separator.isSeparator(choice)) return choice;
+
+    if (typeof choice === "string") {
+      return {
+        value: choice,
+        name: choice,
+        short: choice,
+        disabled: false,
+        checked: false,
+      };
+    }
+
+    const name = choice.name ?? String(choice.value);
+    return {
+      value: choice.value,
+      name,
+      short: choice.short ?? name,
+      description: choice.description,
+      disabled: choice.disabled ?? false,
+      checked: choice.checked ?? false,
+    };
+  });
+}
+
+export default createPrompt((config, done) => {
+  const {
+    instructions,
+    pageSize = 7,
+    loop = true,
+    required,
+    validate = () => true,
+  } = config;
+  const theme = makeTheme(checkboxTheme, config.theme);
+  const firstRender = useRef(true);
+  const [status, setStatus] = useState("idle");
+  const prefix = usePrefix({ status, theme });
+  const [items, setItems] = useState(
+    normalizeChoices(
+      typeof config.choices === "function" ? config.choices([]) : config.choices
+    )
+  );
+
+  const bounds = useMemo(() => {
+    const first = items.findIndex(isSelectable);
+    const last = items.findLastIndex(isSelectable);
+
+    if (first === -1) {
+      throw new ValidationError(
+        "[checkbox prompt] No selectable choices. All choices are disabled."
+      );
+    }
+
+    return { first, last };
+  }, [items]);
+
+  const [active, setActive] = useState(bounds.first);
+  const [showHelpTip, setShowHelpTip] = useState(true);
+  const [errorMsg, setError] = useState();
+
+  useKeypress(async (key) => {
+    if (isEnterKey(key)) {
+      const selection = items.filter(isChecked);
+      const isValid = await validate([...selection]);
+      if (required && !items.some(isChecked)) {
+        setError("At least one choice must be selected");
+      } else if (isValid === true) {
+        setStatus("done");
+        done(selection.map((choice) => choice.value));
+      } else {
+        setError(isValid || "You must select a valid value");
+      }
+    } else if (isUpKey(key) || isDownKey(key)) {
+      if (
+        loop ||
+        (isUpKey(key) && active !== bounds.first) ||
+        (isDownKey(key) && active !== bounds.last)
+      ) {
+        const offset = isUpKey(key) ? -1 : 1;
+        let next = active;
+        do {
+          next = (next + offset + items.length) % items.length;
+        } while (!isSelectable(items[next]));
+        setActive(next);
+      }
+    } else if (isSpaceKey(key)) {
+      setError(undefined);
+      setShowHelpTip(false);
+      let newItems = items.map((choice, i) =>
+        i === active ? toggle(choice) : choice
+      );
+      if (typeof config.choices === "function") {
+        const selected = newItems
+          .filter(isChecked)
+          .map((choice) => choice.value);
+        const choices = config.choices(selected);
+        newItems = newItems.map((choice) => {
+          const updated = choices.find((c) => c.value === choice.value);
+          return { ...choice, ...updated };
+        });
+      }
+      setItems(newItems);
+    } else if (key.name === "a") {
+      const selectAll = items.some(
+        (choice) => isSelectable(choice) && !choice.checked
+      );
+      setItems(items.map(check(selectAll)));
+    } else if (key.name === "i") {
+      setItems(items.map(toggle));
+    } else if (isNumberKey(key)) {
+      // Adjust index to start at 1
+      const position = Number(key.name) - 1;
+      const item = items[position];
+      if (item != null && isSelectable(item)) {
+        setActive(position);
+        setItems(
+          items.map((choice, i) => (i === position ? toggle(choice) : choice))
+        );
+      }
+    }
+  });
+
+  const message = theme.style.message(config.message, status);
+
+  let description;
+  const page = usePagination({
+    items,
+    active,
+    renderItem({ item, isActive }) {
+      if (Separator.isSeparator(item)) {
+        return ` ${item.separator}`;
+      }
+
+      if (item.disabled) {
+        const disabledLabel =
+          typeof item.disabled === "string" ? item.disabled : "(disabled)";
+        return theme.style.disabledChoice(`${item.name} ${disabledLabel}`);
+      }
+
+      if (isActive) {
+        description = item.description;
+      }
+
+      const checkbox = item.checked ? theme.icon.checked : theme.icon.unchecked;
+      const color = isActive ? theme.style.highlight : (x) => x;
+      const cursor = isActive ? theme.icon.cursor : " ";
+      return color(`${cursor}${checkbox} ${item.name}`);
+    },
+    pageSize,
+    loop,
+  });
+
+  if (status === "done") {
+    const selection = items.filter(isChecked);
+    const answer = theme.style.answer(
+      theme.style.renderSelectedChoices(selection, items)
+    );
+
+    return `${prefix} ${message} ${answer}`;
+  }
+
+  let helpTipTop = "";
+  let helpTipBottom = "";
+  if (
+    theme.helpMode === "always" ||
+    (theme.helpMode === "auto" &&
+      showHelpTip &&
+      (instructions === undefined || instructions))
+  ) {
+    if (typeof instructions === "string") {
+      helpTipTop = instructions;
+    } else {
+      const keys = [
+        `${theme.style.key("space")} to select`,
+        `${theme.style.key("a")} to toggle all`,
+        `${theme.style.key("i")} to invert selection`,
+        `and ${theme.style.key("enter")} to proceed`,
+      ];
+      helpTipTop = ` (Press ${keys.join(", ")})`;
+    }
+
+    if (
+      items.length > pageSize &&
+      (theme.helpMode === "always" ||
+        (theme.helpMode === "auto" && firstRender.current))
+    ) {
+      helpTipBottom = `\n${theme.style.help("(Use arrow keys to reveal more choices)")}`;
+      firstRender.current = false;
+    }
+  }
+
+  const choiceDescription = description
+    ? `\n${theme.style.description(description)}`
+    : ``;
+
+  let error = "";
+  if (errorMsg) {
+    error = `\n${theme.style.error(errorMsg)}`;
+  }
+
+  return `${prefix} ${message}${helpTipTop}\n${page}${helpTipBottom}${choiceDescription}${error}${ansiEscapes.cursorHide}`;
+});
+
+export { Separator } from "@inquirer/core";

package/lib/files.mjs

@@ -0,0 +1,6 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+
+export async function json(...path) {
+  return JSON.parse(await readFile(join(...path), "utf8"));
+}

package/lib/formatter.mjs

@@ -0,0 +1,16 @@
+import prettier from "prettier";
+
+export async function format(code, parser) {
+  return prettier.format(code, {
+    parser,
+    printWidth: 80,
+    tabWidth: 2,
+    useTabs: false,
+    semi: true,
+    singleQuote: false,
+    quoteProps: "as-needed",
+    trailingComma: "es5",
+    bracketSpacing: true,
+    bracketSameLine: false,
+  });
+}