@quilted/create 0.2.0 → 0.2.2

package/source/app.ts

@@ -94,88 +94,12 @@ export async function createApp() {
   const appTemplate = loadTemplate(`app-${template}`);
   const workspaceTemplate = loadTemplate('workspace');
 
-  // If we aren’t already in a workspace, copy the workspace files over, which
-  // are needed if we are making a monorepo or not.
   if (!inWorkspace) {
     await workspaceTemplate.copy(directory, (file) => {
-      // When this is a single project, we use the project’s Quilt  configuration as the base.
-      if (file === 'quilt.workspace.ts') return createAsMonorepo;
-
-      // We need to make some adjustments to the root package.json
-      if (file === 'package.json') return false;
-
-      return true;
+      // We will adjust the package.json before writing it
+      return file !== 'package.json';
     });
 
-    // If we are creating a monorepo, we need to add the root package.json and
-    // package manager workspace configuration.
-    if (createAsMonorepo) {
-      const appRelativeToRoot = relativeDirectoryForDisplay(
-        path.relative(directory, appDirectory),
-      );
-
-      const workspacePackageJson = JSON.parse(
-        await workspaceTemplate.read('package.json'),
-      );
-
-      workspacePackageJson.name = toValidPackageName(name!);
-      workspacePackageJson.workspaces = [appRelativeToRoot, './packages/*'];
-
-      if (packageManager.type === 'pnpm') {
-        await outputRoot.write(
-          'pnpm-workspace.yaml',
-          await format(
-            `
-              packages:
-              - '${appRelativeToRoot}'
-              - './packages/*'
-            `,
-            {as: 'yaml'},
-          ),
-        );
-      }
-
-      await outputRoot.write(
-        'package.json',
-        await format(JSON.stringify(workspacePackageJson), {
-          as: 'json-stringify',
-        }),
-      );
-    } else {
-      const [projectPackageJson, projectTSConfig, workspacePackageJson] =
-        await Promise.all([
-          appTemplate
-            .read('package.json')
-            .then((content) => JSON.parse(content)),
-          appTemplate
-            .read('tsconfig.json')
-            .then((content) => JSON.parse(content)),
-          workspaceTemplate
-            .read('package.json')
-            .then((content) => JSON.parse(content)),
-        ]);
-
-      const combinedPackageJson = mergeWorkspaceAndProjectPackageJsons(
-        projectPackageJson,
-        workspacePackageJson,
-      );
-
-      combinedPackageJson.name = toValidPackageName(name!);
-      delete combinedPackageJson.workspaces;
-
-      await outputRoot.write(
-        'package.json',
-        await format(JSON.stringify(combinedPackageJson), {
-          as: 'json-stringify',
-        }),
-      );
-
-      await outputRoot.write(
-        'tsconfig.json',
-        await format(JSON.stringify(projectTSConfig), {as: 'json'}),
-      );
-    }
-
     if (setupExtras.has('github')) {
       await loadTemplate('github').copy(directory);
     }
@@ -185,43 +109,44 @@ export async function createApp() {
     }
   }
 
-  await appTemplate.copy(appDirectory, (file) => {
-    // If we are in a monorepo, we already wrote a merged tsconfig.json
-    if (file === 'tsconfig.json') {
-      return partOfMonorepo;
-    }
-
-    // We need to merge the project gitignore with the workspace one
-    if (file === '_gitignore') return partOfMonorepo;
+  if (createAsMonorepo) {
+    const workspacePackageJson = JSON.parse(
+      await workspaceTemplate.read('package.json'),
+    );
 
-    // We need to make some adjustments the project’s package.json and
-    // quilt config file
-    if (file === 'package.json' || file === 'quilt.project.ts') return false;
+    workspacePackageJson.name = toValidPackageName(name!);
 
-    return true;
-  });
-
-  let quiltProject = await appTemplate.read('quilt.project.ts');
+    const moduleRelativeToRoot = relativeDirectoryForDisplay(
+      path.relative(directory, appDirectory),
+    );
 
-  if (!partOfMonorepo) {
-    quiltProject = quiltProject
-      .replace('quiltApp', 'quiltWorkspace, quiltApp')
-      .replace('quiltApp(', 'quiltWorkspace(), quiltApp(');
+    await outputRoot.write(
+      'pnpm-workspace.yaml',
+      await format(
+        `
+            packages:
+            - './packages/*'
+            - '${moduleRelativeToRoot}'
+          `,
+        {as: 'yaml'},
+      ),
+    );
 
-    if (await appTemplate.has('_gitignore')) {
-      await outputRoot.write(
-        path.join(appDirectory, '.gitignore'),
-        `${await outputRoot.read('.gitignore')}\n${await appTemplate.read(
-          '_gitignore',
-        )}`,
-      );
-    }
+    await outputRoot.write(
+      'package.json',
+      await format(JSON.stringify(workspacePackageJson), {
+        as: 'json-stringify',
+      }),
+    );
   }
 
-  await outputRoot.write(
-    path.join(appDirectory, 'quilt.project.ts'),
-    await format(quiltProject, {as: 'typescript'}),
-  );
+  await appTemplate.copy(appDirectory, (file) => {
+    // We need to merge the project gitignore with the workspace one
+    if (file === '_gitignore') return partOfMonorepo;
+
+    // We will adjust the package.json before writing it
+    return file !== 'package.json';
+  });
 
   if (template === 'graphql' && !inWorkspace) {
     const relativeFromRootToAppPath = (filePath: string) =>
@@ -272,6 +197,38 @@ export async function createApp() {
         packageManager.type,
       ),
     ]);
+  } else {
+    // Write the package’s package.json by combining elements of the root and
+    // package templates
+    const [projectPackageJson, workspacePackageJson] = await Promise.all([
+      appTemplate.read('package.json').then((content) => JSON.parse(content)),
+      workspaceTemplate
+        .read('package.json')
+        .then((content) => JSON.parse(content)),
+    ]);
+
+    const mergedPackageJson = mergeWorkspaceAndProjectPackageJsons(
+      projectPackageJson,
+      workspacePackageJson,
+    );
+
+    mergedPackageJson.name = path.basename(appDirectory);
+
+    await outputRoot.write(
+      'package.json',
+      await format(JSON.stringify(mergedPackageJson), {
+        as: 'json-stringify',
+      }),
+    );
+
+    if (await appTemplate.has('_gitignore')) {
+      await outputRoot.write(
+        path.join(appDirectory, '.gitignore'),
+        `${await outputRoot.read('.gitignore')}\n${await appTemplate.read(
+          '_gitignore',
+        )}`,
+      );
+    }
   }
 
   if (shouldInstall) {

package/source/module.ts

@@ -86,7 +86,7 @@ export async function createModule() {
   const rootDirectory = inWorkspace ? process.cwd() : directory;
   const outputRoot = createOutputTarget(rootDirectory);
   const moduleTemplate = loadTemplate('module');
-  const workspaceTemplate = loadTemplate('workspace-simple');
+  const workspaceTemplate = loadTemplate('workspace');
 
   if (!inWorkspace) {
     await workspaceTemplate.copy(directory, (file) => {
@@ -114,19 +114,17 @@ export async function createModule() {
       path.relative(directory, moduleDirectory),
     );
 
-    if (packageManager.type === 'pnpm') {
-      await outputRoot.write(
-        'pnpm-workspace.yaml',
-        await format(
-          `
+    await outputRoot.write(
+      'pnpm-workspace.yaml',
+      await format(
+        `
             packages:
             - './packages/*'
             - '${moduleRelativeToRoot}'
           `,
-          {as: 'yaml'},
-        ),
-      );
-    }
+        {as: 'yaml'},
+      ),
+    );
 
     await outputRoot.write(
       'package.json',
@@ -137,7 +135,7 @@ export async function createModule() {
   }
 
   await moduleTemplate.copy(moduleDirectory, (file) => {
-    // We will adjust the package.json before writing them
+    // We will adjust the package.json before writing it
     return file !== 'package.json';
   });
 

package/source/package.ts

@@ -103,7 +103,7 @@ export async function createProject() {
   const rootDirectory = inWorkspace ? process.cwd() : directory;
   const outputRoot = createOutputTarget(rootDirectory);
   const packageTemplate = loadTemplate('package');
-  const workspaceTemplate = loadTemplate('workspace-simple');
+  const workspaceTemplate = loadTemplate('workspace');
 
   if (!inWorkspace) {
     await workspaceTemplate.copy(directory, (file) => {
@@ -127,18 +127,16 @@ export async function createProject() {
 
     workspacePackageJson.name = toValidPackageName(name!);
 
-    if (packageManager.type === 'pnpm') {
-      await outputRoot.write(
-        'pnpm-workspace.yaml',
-        await format(
-          `
+    await outputRoot.write(
+      'pnpm-workspace.yaml',
+      await format(
+        `
             packages:
             - './packages/*'
           `,
-          {as: 'yaml'},
-        ),
-      );
-    }
+        {as: 'yaml'},
+      ),
+    );
 
     await outputRoot.write(
       'package.json',

package/source/server.ts

@@ -57,18 +57,18 @@ export async function createServer() {
 
   const partOfMonorepo = inWorkspace || createAsMonorepo;
 
-  const serviceDirectory = createAsMonorepo
+  const serverDirectory = createAsMonorepo
     ? path.join(directory, toValidPackageName(name))
     : directory;
 
   if (fs.existsSync(directory)) {
     await emptyDirectory(directory);
 
-    if (serviceDirectory !== directory) {
-      fs.mkdirSync(serviceDirectory, {recursive: true});
+    if (serverDirectory !== directory) {
+      fs.mkdirSync(serverDirectory, {recursive: true});
     }
   } else {
-    fs.mkdirSync(serviceDirectory, {recursive: true});
+    fs.mkdirSync(serverDirectory, {recursive: true});
   }
 
   const rootDirectory = inWorkspace ? process.cwd() : directory;
@@ -76,88 +76,12 @@ export async function createServer() {
   const serverTemplate = loadTemplate('server-basic');
   const workspaceTemplate = loadTemplate('workspace');
 
-  // If we aren’t already in a workspace, copy the workspace files over, which
-  // are needed if we are making a monorepo or not.
   if (!inWorkspace) {
     await workspaceTemplate.copy(directory, (file) => {
-      // When this is a single project, we use the project’s Quilt  configuration as the base.
-      if (file === 'quilt.workspace.ts') return createAsMonorepo;
-
-      // We need to make some adjustments to the root package.json
-      if (file === 'package.json') return false;
-
-      return true;
+      // We will adjust the package.json before writing it
+      return file !== 'package.json';
     });
 
-    // If we are creating a monorepo, we need to add the root package.json and
-    // package manager workspace configuration.
-    if (createAsMonorepo) {
-      const serviceRelativeToRoot = relativeDirectoryForDisplay(
-        path.relative(directory, serviceDirectory),
-      );
-
-      const workspacePackageJson = JSON.parse(
-        await workspaceTemplate.read('package.json'),
-      );
-
-      workspacePackageJson.name = toValidPackageName(name!);
-      workspacePackageJson.workspaces = [serviceRelativeToRoot, './packages/*'];
-
-      if (packageManager.type === 'pnpm') {
-        await outputRoot.write(
-          'pnpm-workspace.yaml',
-          await format(
-            `
-              packages:
-              - '${serviceRelativeToRoot}'
-              - './packages/*'
-            `,
-            {as: 'yaml'},
-          ),
-        );
-      }
-
-      await outputRoot.write(
-        'package.json',
-        await format(JSON.stringify(workspacePackageJson), {
-          as: 'json-stringify',
-        }),
-      );
-    } else {
-      const [projectPackageJson, projectTSConfig, workspacePackageJson] =
-        await Promise.all([
-          serverTemplate
-            .read('package.json')
-            .then((content) => JSON.parse(content)),
-          serverTemplate
-            .read('tsconfig.json')
-            .then((content) => JSON.parse(content)),
-          workspaceTemplate
-            .read('package.json')
-            .then((content) => JSON.parse(content)),
-        ]);
-
-      const combinedPackageJson = mergeWorkspaceAndProjectPackageJsons(
-        projectPackageJson,
-        workspacePackageJson,
-      );
-
-      adjustPackageJson(combinedPackageJson, {name, entry});
-      delete combinedPackageJson.workspaces;
-
-      await outputRoot.write(
-        'package.json',
-        await format(JSON.stringify(combinedPackageJson), {
-          as: 'json-stringify',
-        }),
-      );
-
-      await outputRoot.write(
-        'tsconfig.json',
-        await format(JSON.stringify(projectTSConfig), {as: 'json'}),
-      );
-    }
-
     if (setupExtras.has('github')) {
       await loadTemplate('github').copy(directory);
     }
@@ -167,43 +91,41 @@ export async function createServer() {
     }
   }
 
-  await serverTemplate.copy(serviceDirectory, (file) => {
-    // If we are in a monorepo, we can use all the template files as they are
-    if (file === 'tsconfig.json') {
-      return partOfMonorepo;
-    }
+  if (createAsMonorepo) {
+    const workspacePackageJson = JSON.parse(
+      await workspaceTemplate.read('package.json'),
+    );
 
-    // We will adjust the entry file, and write an adjusted quilt project file if necessary
-    if (file === 'service.ts' || file === 'quilt.project.ts') {
-      return false;
-    }
+    workspacePackageJson.name = toValidPackageName(name!);
 
-    // We need to make some adjustments the project’s package.json
-    return file !== 'package.json';
-  });
+    const moduleRelativeToRoot = relativeDirectoryForDisplay(
+      path.relative(directory, serverDirectory),
+    );
 
-  let quiltProject = await serverTemplate.read('quilt.project.ts');
+    await outputRoot.write(
+      'pnpm-workspace.yaml',
+      await format(
+        `
+            packages:
+            - './packages/*'
+            - '${moduleRelativeToRoot}'
+          `,
+        {as: 'yaml'},
+      ),
+    );
 
-  if (!partOfMonorepo) {
-    quiltProject = quiltProject
-      .replace('quiltService', 'quiltWorkspace, quiltService')
-      .replace('quiltService(', 'quiltWorkspace(), quiltService(');
+    await outputRoot.write(
+      'package.json',
+      await format(JSON.stringify(workspacePackageJson), {
+        as: 'json-stringify',
+      }),
+    );
   }
 
-  quiltProject = quiltProject.replace(
-    'service.ts',
-    entry.replace(/^\.[/]/, ''),
-  );
-
-  await outputRoot.write(
-    path.join(serviceDirectory, 'quilt.project.ts'),
-    await format(quiltProject, {as: 'typescript'}),
-  );
-
-  await outputRoot.write(
-    path.join(serviceDirectory, entry),
-    await serverTemplate.read('service.ts'),
-  );
+  await serverTemplate.copy(serverDirectory, (file) => {
+    // We will adjust the package.json before writing it
+    return file !== 'package.json';
+  });
 
   if (partOfMonorepo) {
     // Write the app’s package.json (the root one was already created)
@@ -214,20 +136,48 @@ export async function createServer() {
     adjustPackageJson(projectPackageJson, {name, entry});
 
     await outputRoot.write(
-      path.join(serviceDirectory, 'package.json'),
+      path.join(serverDirectory, 'package.json'),
       await format(JSON.stringify(projectPackageJson), {
         as: 'json-stringify',
       }),
     );
 
     await Promise.all([
-      addToTsConfig(serviceDirectory, outputRoot),
+      addToTsConfig(serverDirectory, outputRoot),
       addToPackageManagerWorkspaces(
-        serviceDirectory,
+        serverDirectory,
         outputRoot,
         packageManager.type,
       ),
     ]);
+  } else {
+    // Write the package’s package.json by combining elements of the root and
+    // package templates
+    const [projectPackageJson, workspacePackageJson] = await Promise.all([
+      serverTemplate
+        .read('package.json')
+        .then((content) => JSON.parse(content)),
+      workspaceTemplate
+        .read('package.json')
+        .then((content) => JSON.parse(content)),
+    ]);
+
+    const mergedPackageJson = mergeWorkspaceAndProjectPackageJsons(
+      projectPackageJson,
+      workspacePackageJson,
+    );
+
+    adjustPackageJson(mergedPackageJson, {
+      name: toValidPackageName(name!),
+      entry,
+    });
+
+    await outputRoot.write(
+      'package.json',
+      await format(JSON.stringify(mergedPackageJson), {
+        as: 'json-stringify',
+      }),
+    );
   }
 
   if (shouldInstall) {

package/source/shared.ts

@@ -14,7 +14,6 @@ export function loadTemplate(
     | 'module'
     | 'server-basic'
     | 'workspace'
-    | 'workspace-simple'
     | 'github'
     | 'vscode',
 ) {

package/templates/app-basic/package.json

@@ -21,13 +21,16 @@
   ],
   "browserslist": {
     "defaults": [
-      "extends @quilted/browserslist-config/defaults"
+      "defaults and not dead"
     ],
     "modules": [
-      "extends @quilted/browserslist-config/modules"
+      "defaults and fully supports es6-module and fully supports es6-module-dynamic-import"
     ],
     "evergreen": [
-      "extends @quilted/browserslist-config/evergreen"
+      "last 1 firefox version",
+      "last 1 safari version",
+      "last 1 edge version",
+      "last 1 chrome version"
     ]
   },
   "eslintConfig": {

package/templates/app-basic/rollup.config.js

@@ -0,0 +1,6 @@
+import {quiltApp} from '@quilted/rollup/app';
+
+export default quiltApp({
+  browser: {entry: './browser.tsx'},
+  server: {entry: './server.tsx'},
+});

package/templates/app-basic/server.tsx

@@ -1,6 +1,6 @@
 import '@quilted/quilt/globals';
 import {RequestRouter} from '@quilted/quilt/request-router';
-import {BrowserAssets} from '@quilted/quilt/magic/assets';
+import {BrowserAssets} from 'quilt:module/assets';
 
 const router = new RequestRouter();
 const assets = new BrowserAssets();

package/templates/app-basic/tsconfig.json

@@ -8,6 +8,6 @@
     }
   },
   "include": ["**/*"],
-  "exclude": ["build", "quilt.project.ts"],
+  "exclude": ["build"],
   "references": []
 }

package/templates/app-basic/vite.config.js

@@ -0,0 +1,6 @@
+import {defineConfig} from 'vite';
+import {quiltApp} from '@quilted/vite/app';
+
+export default defineConfig({
+  plugins: [quiltApp()],
+});

package/templates/app-empty/package.json

@@ -21,13 +21,16 @@
   ],
   "browserslist": {
     "defaults": [
-      "extends @quilted/browserslist-config/defaults"
+      "defaults and not dead"
     ],
     "modules": [
-      "extends @quilted/browserslist-config/modules"
+      "defaults and fully supports es6-module and fully supports es6-module-dynamic-import"
     ],
     "evergreen": [
-      "extends @quilted/browserslist-config/evergreen"
+      "last 1 firefox version",
+      "last 1 safari version",
+      "last 1 edge version",
+      "last 1 chrome version"
     ]
   },
   "eslintConfig": {

package/templates/app-empty/rollup.config.js

@@ -0,0 +1,6 @@
+import {quiltApp} from '@quilted/rollup/app';
+
+export default quiltApp({
+  browser: {entry: './browser.tsx'},
+  server: {entry: './server.tsx'},
+});

package/templates/app-empty/server.tsx

@@ -1,6 +1,6 @@
 import '@quilted/quilt/globals';
 import {RequestRouter} from '@quilted/quilt/request-router';
-import {BrowserAssets} from '@quilted/quilt/magic/assets';
+import {BrowserAssets} from 'quilt:module/assets';
 
 const router = new RequestRouter();
 const assets = new BrowserAssets();

package/templates/app-empty/tsconfig.json

@@ -4,6 +4,6 @@
     "outDir": "build/typescript"
   },
   "include": ["**/*"],
-  "exclude": ["build", "quilt.project.ts"],
+  "exclude": ["build"],
   "references": []
 }

package/templates/app-empty/vite.config.js

@@ -0,0 +1,6 @@
+import {defineConfig} from 'vite';
+import {quiltApp} from '@quilted/vite/app';
+
+export default defineConfig({
+  plugins: [quiltApp()],
+});

package/templates/app-graphql/package.json

@@ -24,13 +24,16 @@
   ],
   "browserslist": {
     "defaults": [
-      "extends @quilted/browserslist-config/defaults"
+      "defaults and not dead"
     ],
     "modules": [
-      "extends @quilted/browserslist-config/modules"
+      "defaults and fully supports es6-module and fully supports es6-module-dynamic-import"
     ],
     "evergreen": [
-      "extends @quilted/browserslist-config/evergreen"
+      "last 1 firefox version",
+      "last 1 safari version",
+      "last 1 edge version",
+      "last 1 chrome version"
     ]
   },
   "eslintConfig": {

package/templates/app-graphql/rollup.config.js

@@ -0,0 +1,6 @@
+import {quiltApp} from '@quilted/rollup/app';
+
+export default quiltApp({
+  browser: {entry: './browser.tsx'},
+  server: {entry: './server.tsx'},
+});