914 lines
29 KiB
Plaintext
914 lines
29 KiB
Plaintext
|
import boxen from "boxen";
|
||
|
|
import { diffWords } from "diff";
|
||
|
|
import { execa } from "execa";
|
||
|
|
import { bold, cyan, dim, green, magenta, red, yellow } from "kleur/colors";
|
||
|
|
import fsMod, { existsSync, promises as fs } from "node:fs";
|
||
|
|
import path from "node:path";
|
||
|
|
import { fileURLToPath, pathToFileURL } from "node:url";
|
||
|
|
import maxSatisfying from "semver/ranges/max-satisfying.js";
|
||
|
|
import ora from "ora";
|
||
|
|
import preferredPM from "preferred-pm";
|
||
|
|
import prompts from "prompts";
|
||
|
|
import {
|
||
|
|
loadTSConfig,
|
||
|
|
resolveConfig,
|
||
|
|
resolveConfigPath,
|
||
|
|
resolveRoot
|
||
|
|
} from "../../core/config/index.js";
|
||
|
|
import {
|
||
|
|
defaultTSConfig,
|
||
|
|
presets,
|
||
|
|
updateTSConfigForFramework
|
||
|
|
} from "../../core/config/tsconfig.js";
|
||
|
|
import * as msg from "../../core/messages.js";
|
||
|
|
import { printHelp } from "../../core/messages.js";
|
||
|
|
import { appendForwardSlash } from "../../core/path.js";
|
||
|
|
import { apply as applyPolyfill } from "../../core/polyfill.js";
|
||
|
|
import { ensureProcessNodeEnv, parseNpmName } from "../../core/util.js";
|
||
|
|
import { eventCliSession, telemetry } from "../../events/index.js";
|
||
|
|
import { createLoggerFromFlags, flagsToAstroInlineConfig } from "../flags.js";
|
||
|
|
import { generate, parse, t, visit } from "./babel.js";
|
||
|
|
import { ensureImport } from "./imports.js";
|
||
|
|
import { wrapDefaultExport } from "./wrapper.js";
|
||
|
|
const ALIASES = /* @__PURE__ */ new Map([
|
||
|
|
["solid", "solid-js"],
|
||
|
|
["tailwindcss", "tailwind"]
|
||
|
|
]);
|
||
|
|
const ASTRO_CONFIG_STUB = `import { defineConfig } from 'astro/config';
|
||
|
|
|
||
|
|
export default defineConfig({});`;
|
||
|
|
const TAILWIND_CONFIG_STUB = `/** @type {import('tailwindcss').Config} */
|
||
|
|
export default {
|
||
|
|
content: ['./src/**/*.{astro,html,js,jsx,md,mdx,svelte,ts,tsx,vue}'],
|
||
|
|
theme: {
|
||
|
|
extend: {},
|
||
|
|
},
|
||
|
|
plugins: [],
|
||
|
|
}
|
||
|
|
`;
|
||
|
|
const SVELTE_CONFIG_STUB = `import { vitePreprocess } from '@astrojs/svelte';
|
||
|
|
|
||
|
|
export default {
|
||
|
|
preprocess: vitePreprocess(),
|
||
|
|
};
|
||
|
|
`;
|
||
|
|
const LIT_NPMRC_STUB = `# Lit libraries are required to be hoisted due to dependency issues.
|
||
|
|
public-hoist-pattern[]=*lit*
|
||
|
|
`;
|
||
|
|
const OFFICIAL_ADAPTER_TO_IMPORT_MAP = {
|
||
|
|
netlify: "@astrojs/netlify",
|
||
|
|
vercel: "@astrojs/vercel/serverless",
|
||
|
|
cloudflare: "@astrojs/cloudflare",
|
||
|
|
node: "@astrojs/node"
|
||
|
|
};
|
||
|
|
async function getRegistry() {
|
||
|
|
const packageManager = (await preferredPM(process.cwd()))?.name || "npm";
|
||
|
|
try {
|
||
|
|
const { stdout } = await execa(packageManager, ["config", "get", "registry"]);
|
||
|
|
return stdout?.trim()?.replace(/\/$/, "") || "https://registry.npmjs.org";
|
||
|
|
} catch (e) {
|
||
|
|
return "https://registry.npmjs.org";
|
||
|
|
}
|
||
|
|
}
|
||
|
|
async function add(names, { flags }) {
|
||
|
|
ensureProcessNodeEnv("production");
|
||
|
|
const inlineConfig = flagsToAstroInlineConfig(flags);
|
||
|
|
const { userConfig } = await resolveConfig(inlineConfig, "add");
|
||
|
|
telemetry.record(eventCliSession("add", userConfig));
|
||
|
|
applyPolyfill();
|
||
|
|
if (flags.help || names.length === 0) {
|
||
|
|
printHelp({
|
||
|
|
commandName: "astro add",
|
||
|
|
usage: "[...integrations] [...adapters]",
|
||
|
|
tables: {
|
||
|
|
Flags: [
|
||
|
|
["--yes", "Accept all prompts."],
|
||
|
|
["--help", "Show this help message."]
|
||
|
|
],
|
||
|
|
"UI Frameworks": [
|
||
|
|
["react", "astro add react"],
|
||
|
|
["preact", "astro add preact"],
|
||
|
|
["vue", "astro add vue"],
|
||
|
|
["svelte", "astro add svelte"],
|
||
|
|
["solid-js", "astro add solid-js"],
|
||
|
|
["lit", "astro add lit"],
|
||
|
|
["alpinejs", "astro add alpinejs"]
|
||
|
|
],
|
||
|
|
"Documentation Frameworks": [["starlight", "astro add starlight"]],
|
||
|
|
"SSR Adapters": [
|
||
|
|
["netlify", "astro add netlify"],
|
||
|
|
["vercel", "astro add vercel"],
|
||
|
|
["deno", "astro add deno"],
|
||
|
|
["cloudflare", "astro add cloudflare"],
|
||
|
|
["node", "astro add node"]
|
||
|
|
],
|
||
|
|
Others: [
|
||
|
|
["tailwind", "astro add tailwind"],
|
||
|
|
["image", "astro add image"],
|
||
|
|
["mdx", "astro add mdx"],
|
||
|
|
["partytown", "astro add partytown"],
|
||
|
|
["sitemap", "astro add sitemap"],
|
||
|
|
["prefetch", "astro add prefetch"]
|
||
|
|
]
|
||
|
|
},
|
||
|
|
description: `For more integrations, check out: ${cyan("https://astro.build/integrations")}`
|
||
|
|
});
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
const cwd = flags.root;
|
||
|
|
const logger = createLoggerFromFlags(flags);
|
||
|
|
const integrationNames = names.map((name) => ALIASES.has(name) ? ALIASES.get(name) : name);
|
||
|
|
const integrations = await validateIntegrations(integrationNames);
|
||
|
|
let installResult = await tryToInstallIntegrations({ integrations, cwd, flags, logger });
|
||
|
|
const rootPath = resolveRoot(cwd);
|
||
|
|
const root = pathToFileURL(rootPath);
|
||
|
|
root.href = appendForwardSlash(root.href);
|
||
|
|
switch (installResult) {
|
||
|
|
case 1 /* updated */: {
|
||
|
|
if (integrations.find((integration) => integration.id === "tailwind")) {
|
||
|
|
await setupIntegrationConfig({
|
||
|
|
root,
|
||
|
|
logger,
|
||
|
|
flags,
|
||
|
|
integrationName: "Tailwind",
|
||
|
|
possibleConfigFiles: [
|
||
|
|
"./tailwind.config.cjs",
|
||
|
|
"./tailwind.config.mjs",
|
||
|
|
"./tailwind.config.ts",
|
||
|
|
"./tailwind.config.mts",
|
||
|
|
"./tailwind.config.cts",
|
||
|
|
"./tailwind.config.js"
|
||
|
|
],
|
||
|
|
defaultConfigFile: "./tailwind.config.mjs",
|
||
|
|
defaultConfigContent: TAILWIND_CONFIG_STUB
|
||
|
|
});
|
||
|
|
}
|
||
|
|
if (integrations.find((integration) => integration.id === "svelte")) {
|
||
|
|
await setupIntegrationConfig({
|
||
|
|
root,
|
||
|
|
logger,
|
||
|
|
flags,
|
||
|
|
integrationName: "Svelte",
|
||
|
|
possibleConfigFiles: ["./svelte.config.js", "./svelte.config.cjs", "./svelte.config.mjs"],
|
||
|
|
defaultConfigFile: "./svelte.config.js",
|
||
|
|
defaultConfigContent: SVELTE_CONFIG_STUB
|
||
|
|
});
|
||
|
|
}
|
||
|
|
if (integrations.find((integration) => integration.id === "lit") && (await preferredPM(fileURLToPath(root)))?.name === "pnpm") {
|
||
|
|
await setupIntegrationConfig({
|
||
|
|
root,
|
||
|
|
logger,
|
||
|
|
flags,
|
||
|
|
integrationName: "Lit",
|
||
|
|
possibleConfigFiles: ["./.npmrc"],
|
||
|
|
defaultConfigFile: "./.npmrc",
|
||
|
|
defaultConfigContent: LIT_NPMRC_STUB
|
||
|
|
});
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case 2 /* cancelled */: {
|
||
|
|
logger.info(
|
||
|
|
null,
|
||
|
|
msg.cancelled(
|
||
|
|
`Dependencies ${bold("NOT")} installed.`,
|
||
|
|
`Be sure to install them manually before continuing!`
|
||
|
|
)
|
||
|
|
);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case 3 /* failure */: {
|
||
|
|
throw createPrettyError(new Error(`Unable to install dependencies`));
|
||
|
|
}
|
||
|
|
case 0 /* none */:
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
const rawConfigPath = await resolveConfigPath({
|
||
|
|
root: rootPath,
|
||
|
|
configFile: flags.config,
|
||
|
|
fs: fsMod
|
||
|
|
});
|
||
|
|
let configURL = rawConfigPath ? pathToFileURL(rawConfigPath) : void 0;
|
||
|
|
if (configURL) {
|
||
|
|
logger.debug("add", `Found config at ${configURL}`);
|
||
|
|
} else {
|
||
|
|
logger.info("add", `Unable to locate a config file, generating one for you.`);
|
||
|
|
configURL = new URL("./astro.config.mjs", root);
|
||
|
|
await fs.writeFile(fileURLToPath(configURL), ASTRO_CONFIG_STUB, { encoding: "utf-8" });
|
||
|
|
}
|
||
|
|
let ast = null;
|
||
|
|
try {
|
||
|
|
ast = await parseAstroConfig(configURL);
|
||
|
|
logger.debug("add", "Parsed astro config");
|
||
|
|
const defineConfig = t.identifier("defineConfig");
|
||
|
|
ensureImport(
|
||
|
|
ast,
|
||
|
|
t.importDeclaration(
|
||
|
|
[t.importSpecifier(defineConfig, defineConfig)],
|
||
|
|
t.stringLiteral("astro/config")
|
||
|
|
)
|
||
|
|
);
|
||
|
|
wrapDefaultExport(ast, defineConfig);
|
||
|
|
logger.debug("add", "Astro config ensured `defineConfig`");
|
||
|
|
for (const integration of integrations) {
|
||
|
|
if (isAdapter(integration)) {
|
||
|
|
const officialExportName = OFFICIAL_ADAPTER_TO_IMPORT_MAP[integration.id];
|
||
|
|
if (officialExportName) {
|
||
|
|
await setAdapter(ast, integration, officialExportName);
|
||
|
|
} else {
|
||
|
|
logger.info(
|
||
|
|
null,
|
||
|
|
`
|
||
|
|
${magenta(
|
||
|
|
`Check our deployment docs for ${bold(
|
||
|
|
integration.packageName
|
||
|
|
)} to update your "adapter" config.`
|
||
|
|
)}`
|
||
|
|
);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
await addIntegration(ast, integration);
|
||
|
|
}
|
||
|
|
logger.debug("add", `Astro config added integration ${integration.id}`);
|
||
|
|
}
|
||
|
|
} catch (err) {
|
||
|
|
logger.debug("add", "Error parsing/modifying astro config: ", err);
|
||
|
|
throw createPrettyError(err);
|
||
|
|
}
|
||
|
|
let configResult;
|
||
|
|
if (ast) {
|
||
|
|
try {
|
||
|
|
configResult = await updateAstroConfig({
|
||
|
|
configURL,
|
||
|
|
ast,
|
||
|
|
flags,
|
||
|
|
logger,
|
||
|
|
logAdapterInstructions: integrations.some(isAdapter)
|
||
|
|
});
|
||
|
|
} catch (err) {
|
||
|
|
logger.debug("add", "Error updating astro config", err);
|
||
|
|
throw createPrettyError(err);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
switch (configResult) {
|
||
|
|
case 2 /* cancelled */: {
|
||
|
|
logger.info(null, msg.cancelled(`Your configuration has ${bold("NOT")} been updated.`));
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case 0 /* none */: {
|
||
|
|
const pkgURL = new URL("./package.json", configURL);
|
||
|
|
if (existsSync(fileURLToPath(pkgURL))) {
|
||
|
|
const { dependencies = {}, devDependencies = {} } = await fs.readFile(fileURLToPath(pkgURL)).then((res) => JSON.parse(res.toString()));
|
||
|
|
const deps = Object.keys(Object.assign(dependencies, devDependencies));
|
||
|
|
const missingDeps = integrations.filter(
|
||
|
|
(integration) => !deps.includes(integration.packageName)
|
||
|
|
);
|
||
|
|
if (missingDeps.length === 0) {
|
||
|
|
logger.info(null, msg.success(`Configuration up-to-date.`));
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
logger.info(null, msg.success(`Configuration up-to-date.`));
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
default: {
|
||
|
|
const list = integrations.map((integration) => ` - ${integration.packageName}`).join("\n");
|
||
|
|
logger.info(
|
||
|
|
null,
|
||
|
|
msg.success(
|
||
|
|
`Added the following integration${integrations.length === 1 ? "" : "s"} to your project:
|
||
|
|
${list}`
|
||
|
|
)
|
||
|
|
);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
const updateTSConfigResult = await updateTSConfig(cwd, logger, integrations, flags);
|
||
|
|
switch (updateTSConfigResult) {
|
||
|
|
case 0 /* none */: {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case 2 /* cancelled */: {
|
||
|
|
logger.info(
|
||
|
|
null,
|
||
|
|
msg.cancelled(`Your TypeScript configuration has ${bold("NOT")} been updated.`)
|
||
|
|
);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case 3 /* failure */: {
|
||
|
|
throw new Error(
|
||
|
|
`Unknown error parsing tsconfig.json or jsconfig.json. Could not update TypeScript settings.`
|
||
|
|
);
|
||
|
|
}
|
||
|
|
default:
|
||
|
|
logger.info(null, msg.success(`Successfully updated TypeScript settings`));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function isAdapter(integration) {
|
||
|
|
return integration.type === "adapter";
|
||
|
|
}
|
||
|
|
async function parseAstroConfig(configURL) {
|
||
|
|
const source = await fs.readFile(fileURLToPath(configURL), { encoding: "utf-8" });
|
||
|
|
const result = parse(source);
|
||
|
|
if (!result)
|
||
|
|
throw new Error("Unknown error parsing astro config");
|
||
|
|
if (result.errors.length > 0)
|
||
|
|
throw new Error("Error parsing astro config: " + JSON.stringify(result.errors));
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
const toIdent = (name) => {
|
||
|
|
const ident = name.trim().replace(/[-_\.\/]?astro(?:js)?[-_\.]?/g, "").replace(/\.js/, "").replace(/(?:[\.\-\_\/]+)([a-zA-Z])/g, (_, w) => w.toUpperCase()).replace(/^[^a-zA-Z$_]+/, "");
|
||
|
|
return `${ident[0].toLowerCase()}${ident.slice(1)}`;
|
||
|
|
};
|
||
|
|
function createPrettyError(err) {
|
||
|
|
err.message = `Astro could not update your astro.config.js file safely.
|
||
|
|
Reason: ${err.message}
|
||
|
|
|
||
|
|
You will need to add these integration(s) manually.
|
||
|
|
Documentation: https://docs.astro.build/en/guides/integrations-guide/`;
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
async function addIntegration(ast, integration) {
|
||
|
|
const integrationId = t.identifier(toIdent(integration.id));
|
||
|
|
ensureImport(
|
||
|
|
ast,
|
||
|
|
t.importDeclaration(
|
||
|
|
[t.importDefaultSpecifier(integrationId)],
|
||
|
|
t.stringLiteral(integration.packageName)
|
||
|
|
)
|
||
|
|
);
|
||
|
|
visit(ast, {
|
||
|
|
// eslint-disable-next-line @typescript-eslint/no-shadow
|
||
|
|
ExportDefaultDeclaration(path2) {
|
||
|
|
if (!t.isCallExpression(path2.node.declaration))
|
||
|
|
return;
|
||
|
|
const configObject = path2.node.declaration.arguments[0];
|
||
|
|
if (!t.isObjectExpression(configObject))
|
||
|
|
return;
|
||
|
|
let integrationsProp = configObject.properties.find((prop) => {
|
||
|
|
if (prop.type !== "ObjectProperty")
|
||
|
|
return false;
|
||
|
|
if (prop.key.type === "Identifier") {
|
||
|
|
if (prop.key.name === "integrations")
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
if (prop.key.type === "StringLiteral") {
|
||
|
|
if (prop.key.value === "integrations")
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
});
|
||
|
|
const integrationCall = t.callExpression(integrationId, []);
|
||
|
|
if (!integrationsProp) {
|
||
|
|
configObject.properties.push(
|
||
|
|
t.objectProperty(t.identifier("integrations"), t.arrayExpression([integrationCall]))
|
||
|
|
);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (integrationsProp.value.type !== "ArrayExpression")
|
||
|
|
throw new Error("Unable to parse integrations");
|
||
|
|
const existingIntegrationCall = integrationsProp.value.elements.find(
|
||
|
|
(expr) => t.isCallExpression(expr) && t.isIdentifier(expr.callee) && expr.callee.name === integrationId.name
|
||
|
|
);
|
||
|
|
if (existingIntegrationCall)
|
||
|
|
return;
|
||
|
|
integrationsProp.value.elements.push(integrationCall);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}
|
||
|
|
async function setAdapter(ast, adapter, exportName) {
|
||
|
|
const adapterId = t.identifier(toIdent(adapter.id));
|
||
|
|
ensureImport(
|
||
|
|
ast,
|
||
|
|
t.importDeclaration([t.importDefaultSpecifier(adapterId)], t.stringLiteral(exportName))
|
||
|
|
);
|
||
|
|
visit(ast, {
|
||
|
|
// eslint-disable-next-line @typescript-eslint/no-shadow
|
||
|
|
ExportDefaultDeclaration(path2) {
|
||
|
|
if (!t.isCallExpression(path2.node.declaration))
|
||
|
|
return;
|
||
|
|
const configObject = path2.node.declaration.arguments[0];
|
||
|
|
if (!t.isObjectExpression(configObject))
|
||
|
|
return;
|
||
|
|
let outputProp = configObject.properties.find((prop) => {
|
||
|
|
if (prop.type !== "ObjectProperty")
|
||
|
|
return false;
|
||
|
|
if (prop.key.type === "Identifier") {
|
||
|
|
if (prop.key.name === "output")
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
if (prop.key.type === "StringLiteral") {
|
||
|
|
if (prop.key.value === "output")
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
});
|
||
|
|
if (!outputProp) {
|
||
|
|
configObject.properties.push(
|
||
|
|
t.objectProperty(t.identifier("output"), t.stringLiteral("server"))
|
||
|
|
);
|
||
|
|
}
|
||
|
|
let adapterProp = configObject.properties.find((prop) => {
|
||
|
|
if (prop.type !== "ObjectProperty")
|
||
|
|
return false;
|
||
|
|
if (prop.key.type === "Identifier") {
|
||
|
|
if (prop.key.name === "adapter")
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
if (prop.key.type === "StringLiteral") {
|
||
|
|
if (prop.key.value === "adapter")
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
});
|
||
|
|
let adapterCall;
|
||
|
|
switch (adapter.id) {
|
||
|
|
case "node": {
|
||
|
|
adapterCall = t.callExpression(adapterId, [
|
||
|
|
t.objectExpression([
|
||
|
|
t.objectProperty(t.identifier("mode"), t.stringLiteral("standalone"))
|
||
|
|
])
|
||
|
|
]);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
default: {
|
||
|
|
adapterCall = t.callExpression(adapterId, []);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (!adapterProp) {
|
||
|
|
configObject.properties.push(t.objectProperty(t.identifier("adapter"), adapterCall));
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
adapterProp.value = adapterCall;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}
|
||
|
|
var UpdateResult = /* @__PURE__ */ ((UpdateResult2) => {
|
||
|
|
UpdateResult2[UpdateResult2["none"] = 0] = "none";
|
||
|
|
UpdateResult2[UpdateResult2["updated"] = 1] = "updated";
|
||
|
|
UpdateResult2[UpdateResult2["cancelled"] = 2] = "cancelled";
|
||
|
|
UpdateResult2[UpdateResult2["failure"] = 3] = "failure";
|
||
|
|
return UpdateResult2;
|
||
|
|
})(UpdateResult || {});
|
||
|
|
async function updateAstroConfig({
|
||
|
|
configURL,
|
||
|
|
ast,
|
||
|
|
flags,
|
||
|
|
logger,
|
||
|
|
logAdapterInstructions
|
||
|
|
}) {
|
||
|
|
const input = await fs.readFile(fileURLToPath(configURL), { encoding: "utf-8" });
|
||
|
|
let output = await generate(ast);
|
||
|
|
const comment = "// https://astro.build/config";
|
||
|
|
const defaultExport = "export default defineConfig";
|
||
|
|
output = output.replace(`
|
||
|
|
${comment}`, "");
|
||
|
|
output = output.replace(`${defaultExport}`, `
|
||
|
|
${comment}
|
||
|
|
${defaultExport}`);
|
||
|
|
if (input === output) {
|
||
|
|
return 0 /* none */;
|
||
|
|
}
|
||
|
|
const diff = getDiffContent(input, output);
|
||
|
|
if (!diff) {
|
||
|
|
return 0 /* none */;
|
||
|
|
}
|
||
|
|
const message = `
|
||
|
|
${boxen(diff, {
|
||
|
|
margin: 0.5,
|
||
|
|
padding: 0.5,
|
||
|
|
borderStyle: "round",
|
||
|
|
title: configURL.pathname.split("/").pop()
|
||
|
|
})}
|
||
|
|
`;
|
||
|
|
logger.info(
|
||
|
|
null,
|
||
|
|
`
|
||
|
|
${magenta("Astro will make the following changes to your config file:")}
|
||
|
|
${message}`
|
||
|
|
);
|
||
|
|
if (logAdapterInstructions) {
|
||
|
|
logger.info(
|
||
|
|
null,
|
||
|
|
magenta(
|
||
|
|
` For complete deployment options, visit
|
||
|
|
${bold(
|
||
|
|
"https://docs.astro.build/en/guides/deploy/"
|
||
|
|
)}
|
||
|
|
`
|
||
|
|
)
|
||
|
|
);
|
||
|
|
}
|
||
|
|
if (await askToContinue({ flags })) {
|
||
|
|
await fs.writeFile(fileURLToPath(configURL), output, { encoding: "utf-8" });
|
||
|
|
logger.debug("add", `Updated astro config`);
|
||
|
|
return 1 /* updated */;
|
||
|
|
} else {
|
||
|
|
return 2 /* cancelled */;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
async function getInstallIntegrationsCommand({
|
||
|
|
integrations,
|
||
|
|
logger,
|
||
|
|
cwd = process.cwd()
|
||
|
|
}) {
|
||
|
|
const pm = await preferredPM(cwd);
|
||
|
|
logger.debug("add", `package manager: ${JSON.stringify(pm)}`);
|
||
|
|
if (!pm)
|
||
|
|
return null;
|
||
|
|
const dependencies = await convertIntegrationsToInstallSpecifiers(integrations);
|
||
|
|
switch (pm.name) {
|
||
|
|
case "npm":
|
||
|
|
return { pm: "npm", command: "install", flags: [], dependencies };
|
||
|
|
case "yarn":
|
||
|
|
return { pm: "yarn", command: "add", flags: [], dependencies };
|
||
|
|
case "pnpm":
|
||
|
|
return { pm: "pnpm", command: "add", flags: [], dependencies };
|
||
|
|
case "bun":
|
||
|
|
return { pm: "bun", command: "add", flags: [], dependencies };
|
||
|
|
default:
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
async function convertIntegrationsToInstallSpecifiers(integrations) {
|
||
|
|
const ranges = {};
|
||
|
|
for (let { packageName, dependencies } of integrations) {
|
||
|
|
ranges[packageName] = "*";
|
||
|
|
for (const [name, range] of dependencies) {
|
||
|
|
ranges[name] = range;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return Promise.all(
|
||
|
|
Object.entries(ranges).map(([name, range]) => resolveRangeToInstallSpecifier(name, range))
|
||
|
|
);
|
||
|
|
}
|
||
|
|
async function resolveRangeToInstallSpecifier(name, range) {
|
||
|
|
const versions = await fetchPackageVersions(name);
|
||
|
|
if (versions instanceof Error)
|
||
|
|
return name;
|
||
|
|
const stableVersions = versions.filter((v) => !v.includes("-"));
|
||
|
|
const maxStable = maxSatisfying(stableVersions, range);
|
||
|
|
return `${name}@^${maxStable}`;
|
||
|
|
}
|
||
|
|
const INHERITED_FLAGS = /* @__PURE__ */ new Set([
|
||
|
|
"P",
|
||
|
|
"save-prod",
|
||
|
|
"D",
|
||
|
|
"save-dev",
|
||
|
|
"E",
|
||
|
|
"save-exact",
|
||
|
|
"no-save"
|
||
|
|
]);
|
||
|
|
async function tryToInstallIntegrations({
|
||
|
|
integrations,
|
||
|
|
cwd,
|
||
|
|
flags,
|
||
|
|
logger
|
||
|
|
}) {
|
||
|
|
const installCommand = await getInstallIntegrationsCommand({ integrations, cwd, logger });
|
||
|
|
const inheritedFlags = Object.entries(flags).map(([flag]) => {
|
||
|
|
if (flag == "_")
|
||
|
|
return;
|
||
|
|
if (INHERITED_FLAGS.has(flag)) {
|
||
|
|
if (flag.length === 1)
|
||
|
|
return `-${flag}`;
|
||
|
|
return `--${flag}`;
|
||
|
|
}
|
||
|
|
}).filter(Boolean).flat();
|
||
|
|
if (installCommand === null) {
|
||
|
|
return 0 /* none */;
|
||
|
|
} else {
|
||
|
|
const coloredOutput = `${bold(installCommand.pm)} ${installCommand.command}${[
|
||
|
|
"",
|
||
|
|
...installCommand.flags,
|
||
|
|
...inheritedFlags
|
||
|
|
].join(" ")} ${cyan(installCommand.dependencies.join(" "))}`;
|
||
|
|
const message = `
|
||
|
|
${boxen(coloredOutput, {
|
||
|
|
margin: 0.5,
|
||
|
|
padding: 0.5,
|
||
|
|
borderStyle: "round"
|
||
|
|
})}
|
||
|
|
`;
|
||
|
|
logger.info(
|
||
|
|
null,
|
||
|
|
`
|
||
|
|
${magenta("Astro will run the following command:")}
|
||
|
|
${dim(
|
||
|
|
"If you skip this step, you can always run it yourself later"
|
||
|
|
)}
|
||
|
|
${message}`
|
||
|
|
);
|
||
|
|
if (await askToContinue({ flags })) {
|
||
|
|
const spinner = ora("Installing dependencies...").start();
|
||
|
|
try {
|
||
|
|
await execa(
|
||
|
|
installCommand.pm,
|
||
|
|
[
|
||
|
|
installCommand.command,
|
||
|
|
...installCommand.flags,
|
||
|
|
...inheritedFlags,
|
||
|
|
...installCommand.dependencies
|
||
|
|
],
|
||
|
|
{
|
||
|
|
cwd,
|
||
|
|
// reset NODE_ENV to ensure install command run in dev mode
|
||
|
|
env: { NODE_ENV: void 0 }
|
||
|
|
}
|
||
|
|
);
|
||
|
|
spinner.succeed();
|
||
|
|
return 1 /* updated */;
|
||
|
|
} catch (err) {
|
||
|
|
spinner.fail();
|
||
|
|
logger.debug("add", "Error installing dependencies", err);
|
||
|
|
console.error("\n", err.stdout || err.message, "\n");
|
||
|
|
return 3 /* failure */;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
return 2 /* cancelled */;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
async function fetchPackageJson(scope, name, tag) {
|
||
|
|
const packageName = `${scope ? `${scope}/` : ""}${name}`;
|
||
|
|
const registry = await getRegistry();
|
||
|
|
const res = await fetch(`${registry}/${packageName}/${tag}`);
|
||
|
|
if (res.status >= 200 && res.status < 300) {
|
||
|
|
return await res.json();
|
||
|
|
} else if (res.status === 404) {
|
||
|
|
return new Error();
|
||
|
|
} else {
|
||
|
|
return new Error(`Failed to fetch ${registry}/${packageName}/${tag} - GET ${res.status}`);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
async function fetchPackageVersions(packageName) {
|
||
|
|
const registry = await getRegistry();
|
||
|
|
const res = await fetch(`${registry}/${packageName}`, {
|
||
|
|
headers: { accept: "application/vnd.npm.install-v1+json" }
|
||
|
|
});
|
||
|
|
if (res.status >= 200 && res.status < 300) {
|
||
|
|
return await res.json().then((data) => Object.keys(data.versions));
|
||
|
|
} else if (res.status === 404) {
|
||
|
|
return new Error();
|
||
|
|
} else {
|
||
|
|
return new Error(`Failed to fetch ${registry}/${packageName} - GET ${res.status}`);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
async function validateIntegrations(integrations) {
|
||
|
|
const spinner = ora("Resolving packages...").start();
|
||
|
|
try {
|
||
|
|
const integrationEntries = await Promise.all(
|
||
|
|
integrations.map(async (integration) => {
|
||
|
|
const parsed = parseIntegrationName(integration);
|
||
|
|
if (!parsed) {
|
||
|
|
throw new Error(`${bold(integration)} does not appear to be a valid package name!`);
|
||
|
|
}
|
||
|
|
let { scope, name, tag } = parsed;
|
||
|
|
let pkgJson;
|
||
|
|
let pkgType;
|
||
|
|
if (scope && scope !== "@astrojs") {
|
||
|
|
pkgType = "third-party";
|
||
|
|
} else {
|
||
|
|
const firstPartyPkgCheck = await fetchPackageJson("@astrojs", name, tag);
|
||
|
|
if (firstPartyPkgCheck instanceof Error) {
|
||
|
|
if (firstPartyPkgCheck.message) {
|
||
|
|
spinner.warn(yellow(firstPartyPkgCheck.message));
|
||
|
|
}
|
||
|
|
spinner.warn(
|
||
|
|
yellow(`${bold(integration)} is not an official Astro package. Use at your own risk!`)
|
||
|
|
);
|
||
|
|
const response = await prompts({
|
||
|
|
type: "confirm",
|
||
|
|
name: "askToContinue",
|
||
|
|
message: "Continue?",
|
||
|
|
initial: true
|
||
|
|
});
|
||
|
|
if (!response.askToContinue) {
|
||
|
|
throw new Error(
|
||
|
|
`No problem! Find our official integrations at ${cyan(
|
||
|
|
"https://astro.build/integrations"
|
||
|
|
)}`
|
||
|
|
);
|
||
|
|
}
|
||
|
|
spinner.start("Resolving with third party packages...");
|
||
|
|
pkgType = "third-party";
|
||
|
|
} else {
|
||
|
|
pkgType = "first-party";
|
||
|
|
pkgJson = firstPartyPkgCheck;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (pkgType === "third-party") {
|
||
|
|
const thirdPartyPkgCheck = await fetchPackageJson(scope, name, tag);
|
||
|
|
if (thirdPartyPkgCheck instanceof Error) {
|
||
|
|
if (thirdPartyPkgCheck.message) {
|
||
|
|
spinner.warn(yellow(thirdPartyPkgCheck.message));
|
||
|
|
}
|
||
|
|
throw new Error(`Unable to fetch ${bold(integration)}. Does the package exist?`);
|
||
|
|
} else {
|
||
|
|
pkgJson = thirdPartyPkgCheck;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
const resolvedScope = pkgType === "first-party" ? "@astrojs" : scope;
|
||
|
|
const packageName = `${resolvedScope ? `${resolvedScope}/` : ""}${name}`;
|
||
|
|
let dependencies = [
|
||
|
|
[pkgJson["name"], `^${pkgJson["version"]}`]
|
||
|
|
];
|
||
|
|
if (pkgJson["peerDependencies"]) {
|
||
|
|
const meta = pkgJson["peerDependenciesMeta"] || {};
|
||
|
|
for (const peer in pkgJson["peerDependencies"]) {
|
||
|
|
const optional = meta[peer]?.optional || false;
|
||
|
|
const isAstro = peer === "astro";
|
||
|
|
if (!optional && !isAstro) {
|
||
|
|
dependencies.push([peer, pkgJson["peerDependencies"][peer]]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
let integrationType;
|
||
|
|
const keywords = Array.isArray(pkgJson["keywords"]) ? pkgJson["keywords"] : [];
|
||
|
|
if (keywords.includes("astro-integration")) {
|
||
|
|
integrationType = "integration";
|
||
|
|
} else if (keywords.includes("astro-adapter")) {
|
||
|
|
integrationType = "adapter";
|
||
|
|
} else {
|
||
|
|
throw new Error(
|
||
|
|
`${bold(
|
||
|
|
packageName
|
||
|
|
)} doesn't appear to be an integration or an adapter. Find our official integrations at ${cyan(
|
||
|
|
"https://astro.build/integrations"
|
||
|
|
)}`
|
||
|
|
);
|
||
|
|
}
|
||
|
|
return { id: integration, packageName, dependencies, type: integrationType };
|
||
|
|
})
|
||
|
|
);
|
||
|
|
spinner.succeed();
|
||
|
|
return integrationEntries;
|
||
|
|
} catch (e) {
|
||
|
|
if (e instanceof Error) {
|
||
|
|
spinner.fail(e.message);
|
||
|
|
process.exit(1);
|
||
|
|
} else {
|
||
|
|
throw e;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
async function updateTSConfig(cwd = process.cwd(), logger, integrationsInfo, flags) {
|
||
|
|
const integrations = integrationsInfo.map(
|
||
|
|
(integration) => integration.id
|
||
|
|
);
|
||
|
|
const firstIntegrationWithTSSettings = integrations.find(
|
||
|
|
(integration) => presets.has(integration)
|
||
|
|
);
|
||
|
|
if (!firstIntegrationWithTSSettings) {
|
||
|
|
return 0 /* none */;
|
||
|
|
}
|
||
|
|
let inputConfig = await loadTSConfig(cwd);
|
||
|
|
let inputConfigText = "";
|
||
|
|
if (inputConfig === "invalid-config" || inputConfig === "unknown-error") {
|
||
|
|
return 3 /* failure */;
|
||
|
|
} else if (inputConfig === "missing-config") {
|
||
|
|
logger.debug("add", "Couldn't find tsconfig.json or jsconfig.json, generating one");
|
||
|
|
inputConfig = {
|
||
|
|
tsconfig: defaultTSConfig,
|
||
|
|
tsconfigFile: path.join(cwd, "tsconfig.json"),
|
||
|
|
rawConfig: { tsconfig: defaultTSConfig, tsconfigFile: path.join(cwd, "tsconfig.json") }
|
||
|
|
};
|
||
|
|
} else {
|
||
|
|
inputConfigText = JSON.stringify(inputConfig.rawConfig.tsconfig, null, 2);
|
||
|
|
}
|
||
|
|
const configFileName = path.basename(inputConfig.tsconfigFile);
|
||
|
|
const outputConfig = updateTSConfigForFramework(
|
||
|
|
inputConfig.rawConfig.tsconfig,
|
||
|
|
firstIntegrationWithTSSettings
|
||
|
|
);
|
||
|
|
const output = JSON.stringify(outputConfig, null, 2);
|
||
|
|
const diff = getDiffContent(inputConfigText, output);
|
||
|
|
if (!diff) {
|
||
|
|
return 0 /* none */;
|
||
|
|
}
|
||
|
|
const message = `
|
||
|
|
${boxen(diff, {
|
||
|
|
margin: 0.5,
|
||
|
|
padding: 0.5,
|
||
|
|
borderStyle: "round",
|
||
|
|
title: configFileName
|
||
|
|
})}
|
||
|
|
`;
|
||
|
|
logger.info(
|
||
|
|
null,
|
||
|
|
`
|
||
|
|
${magenta(`Astro will make the following changes to your ${configFileName}:`)}
|
||
|
|
${message}`
|
||
|
|
);
|
||
|
|
const conflictingIntegrations = [...Object.keys(presets).filter((config) => config !== "vue")];
|
||
|
|
const hasConflictingIntegrations = integrations.filter((integration) => presets.has(integration)).length > 1 && integrations.filter((integration) => conflictingIntegrations.includes(integration)).length > 0;
|
||
|
|
if (hasConflictingIntegrations) {
|
||
|
|
logger.info(
|
||
|
|
null,
|
||
|
|
red(
|
||
|
|
` ${bold(
|
||
|
|
"Caution:"
|
||
|
|
)} Selected UI frameworks require conflicting tsconfig.json settings, as such only settings for ${bold(
|
||
|
|
firstIntegrationWithTSSettings
|
||
|
|
)} were used.
|
||
|
|
More information: https://docs.astro.build/en/guides/typescript/#errors-typing-multiple-jsx-frameworks-at-the-same-time
|
||
|
|
`
|
||
|
|
)
|
||
|
|
);
|
||
|
|
}
|
||
|
|
if (await askToContinue({ flags })) {
|
||
|
|
await fs.writeFile(inputConfig.tsconfigFile, output, {
|
||
|
|
encoding: "utf-8"
|
||
|
|
});
|
||
|
|
logger.debug("add", `Updated ${configFileName} file`);
|
||
|
|
return 1 /* updated */;
|
||
|
|
} else {
|
||
|
|
return 2 /* cancelled */;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function parseIntegrationName(spec) {
|
||
|
|
const result = parseNpmName(spec);
|
||
|
|
if (!result)
|
||
|
|
return;
|
||
|
|
let { scope, name } = result;
|
||
|
|
let tag = "latest";
|
||
|
|
if (scope) {
|
||
|
|
name = name.replace(scope + "/", "");
|
||
|
|
}
|
||
|
|
if (name.includes("@")) {
|
||
|
|
const tagged = name.split("@");
|
||
|
|
name = tagged[0];
|
||
|
|
tag = tagged[1];
|
||
|
|
}
|
||
|
|
return { scope, name, tag };
|
||
|
|
}
|
||
|
|
async function askToContinue({ flags }) {
|
||
|
|
if (flags.yes || flags.y)
|
||
|
|
return true;
|
||
|
|
const response = await prompts({
|
||
|
|
type: "confirm",
|
||
|
|
name: "askToContinue",
|
||
|
|
message: "Continue?",
|
||
|
|
initial: true
|
||
|
|
});
|
||
|
|
return Boolean(response.askToContinue);
|
||
|
|
}
|
||
|
|
function getDiffContent(input, output) {
|
||
|
|
let changes = [];
|
||
|
|
for (const change of diffWords(input, output)) {
|
||
|
|
let lines = change.value.trim().split("\n").slice(0, change.count);
|
||
|
|
if (lines.length === 0)
|
||
|
|
continue;
|
||
|
|
if (change.added) {
|
||
|
|
if (!change.value.trim())
|
||
|
|
continue;
|
||
|
|
changes.push(change.value);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (changes.length === 0) {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
let diffed = output;
|
||
|
|
for (let newContent of changes) {
|
||
|
|
const coloredOutput = newContent.split("\n").map((ln) => ln ? green(ln) : "").join("\n");
|
||
|
|
diffed = diffed.replace(newContent, coloredOutput);
|
||
|
|
}
|
||
|
|
return diffed;
|
||
|
|
}
|
||
|
|
async function setupIntegrationConfig(opts) {
|
||
|
|
const logger = opts.logger;
|
||
|
|
const possibleConfigFiles = opts.possibleConfigFiles.map(
|
||
|
|
(p) => fileURLToPath(new URL(p, opts.root))
|
||
|
|
);
|
||
|
|
let alreadyConfigured = false;
|
||
|
|
for (const possibleConfigPath of possibleConfigFiles) {
|
||
|
|
if (existsSync(possibleConfigPath)) {
|
||
|
|
alreadyConfigured = true;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (!alreadyConfigured) {
|
||
|
|
logger.info(
|
||
|
|
null,
|
||
|
|
`
|
||
|
|
${magenta(`Astro will generate a minimal ${bold(opts.defaultConfigFile)} file.`)}
|
||
|
|
`
|
||
|
|
);
|
||
|
|
if (await askToContinue({ flags: opts.flags })) {
|
||
|
|
await fs.writeFile(
|
||
|
|
fileURLToPath(new URL(opts.defaultConfigFile, opts.root)),
|
||
|
|
opts.defaultConfigContent,
|
||
|
|
{
|
||
|
|
encoding: "utf-8"
|
||
|
|
}
|
||
|
|
);
|
||
|
|
logger.debug("add", `Generated default ${opts.defaultConfigFile} file`);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
logger.debug("add", `Using existing ${opts.integrationName} configuration`);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
export {
|
||
|
|
add,
|
||
|
|
validateIntegrations
|
||
|
|
};
|