@joystick.js/cli-canary 0.0.0-canary.162 → 0.0.0-canary.1621

package/src/commands/test/definition.js

@@ -0,0 +1,28 @@
+import test from './index.js';
+
+const [_node, _bin, ...raw_args] = process.argv;
+
+const definition = {
+  description: 'Start an existing Joystick app and run its tests.',
+  args: {},
+  options: {
+    watch: {
+      flags: {
+        '-w': {
+          set: !!raw_args.includes('-w'),
+          value: !!raw_args.includes('-w'),
+          parent: 'test'
+        },
+        '--watch': {
+          set: !!raw_args.includes('--watch'),
+          value: !!raw_args.includes('--watch'),
+          parent: 'test'
+        },
+      },
+      description: 'Run joystick test in watch mode.',
+    },
+  },
+  command: test,
+};
+
+export default definition;

package/src/commands/test/index.js

@@ -0,0 +1,12 @@
+import development_server from "../../lib/development_server/index.js";
+
+const test = async (args = {}, options = {}) => {
+  await development_server({
+    environment: 'test',
+    process,
+    port: 1977,
+    watch: options?.watch,
+  });
+};
+
+export default test;

package/src/commands/update/definition.js

@@ -0,0 +1,28 @@
+import update from './index.js';
+
+const [_node, _bin, ...raw_args] = process.argv;
+
+const definition = {
+  description: 'Update all Joystick packages to their latest version.',
+  args: {},
+  options: {
+    release: {
+      flags: {
+        '-r': {
+          set: !!raw_args.includes('-r'),
+          value: !!raw_args.includes('-r') && raw_args[raw_args.indexOf('-r') + 1],
+          parent: 'create',
+        },
+        '--release': {
+          set: !!raw_args.includes('--release'),
+          value: !!raw_args.includes('--release') && raw_args[raw_args.indexOf('--release') + 1],
+          parent: 'create',
+        },
+      },
+      description: 'The release of Joystick to update (production or canary).',
+    },
+  },
+  command: update,
+};
+
+export default definition;

package/src/commands/update/index.js

@@ -0,0 +1,29 @@
+import chalk from 'chalk';
+import child_process from "child_process";
+import util from 'util';
+import color_log from "../../lib/color_log.js";
+import Loader from "../../lib/loader.js";
+
+const exec = util.promisify(child_process.exec);
+
+const update = async (args = {}, options = {}) => {
+	process.loader = new Loader();
+  process.loader.print('Updating Joystick dependencies...');
+
+  process.loader.print(`Updating @joystick.js/node${options?.relase === 'canary' ? '-canary' : ''}...`);
+  await exec(`npm i @joystick.js/node${options?.relase === 'canary' ? '-canary' : ''}@latest`);
+
+  process.loader.print(`Updating @joystick.js/test${options?.relase === 'canary' ? '-canary' : ''}...`);
+  await exec(`npm i @joystick.js/test${options?.relase === 'canary' ? '-canary' : ''}@latest`);
+
+  process.loader.print(`Updating @joystick.js/ui${options?.relase === 'canary' ? '-canary' : ''}...`);
+  await exec(`npm i @joystick.js/ui${options?.relase === 'canary' ? '-canary' : ''}@latest`);
+	
+	process.loader.print(`Updating @joystick.js/cli${options?.relase === 'canary' ? '-canary' : ''}...`);
+	await exec(`npm i -g @joystick.js/cli${options?.relase === 'canary' ? '-canary' : ''}@latest`);
+
+  color_log('✔ Joystick updated!', 'green');
+  process.exit(0);
+};
+
+export default update;

package/src/commands/use/definition.js

@@ -0,0 +1,19 @@
+import use from './index.js';
+
+const [_node, _bin, ...raw_args] = process.argv;
+
+const definition = {
+  description: 'Decides which release of Joystick to use (production or canary).',
+  args: {
+    release: {
+      set: !!raw_args.includes('use') && !!raw_args[raw_args.indexOf('use') + 1],
+      parent: 'use',
+      value: !!raw_args.includes('use') && raw_args[raw_args.indexOf('use') + 1],
+      description: 'The release of Joystick to use (production or canary).',
+    },
+  },
+  options: {},
+  command: use
+};
+
+export default definition;

package/src/commands/use/index.js

@@ -0,0 +1,54 @@
+import child_process from "child_process";
+import util from 'util';
+import Loader from '../../lib/loader.js';
+import replace_in_files from '../../lib/replace_in_files.js';
+
+const exec = util.promisify(child_process.exec);
+
+const use = async (args = {}, options = {}) => {
+  const loader = new Loader();
+
+  if (args?.release === 'canary') {
+    await replace_in_files(process.cwd(), {
+      match: [/\.js$/],
+      exclude: [/node_modules/],
+      replace_regex: /(@joystick\.js\/node)(?!-)/g,
+      replace_with: '@joystick.js/node-canary',
+    });
+
+    await replace_in_files(process.cwd(), {
+      match: [/\.js$/],
+      exclude: [/node_modules/],
+      replace_regex: /(@joystick\.js\/ui)(?!-)/g,
+      replace_with: '@joystick.js/ui-canary',
+    });
+    
+    loader.print('Swapping production packages for canary versions...');
+    
+    await exec('npm uninstall @joystick.js/node && npm i @joystick.js/node-canary');
+    await exec('npm uninstall @joystick.js/ui && npm i @joystick.js/ui-canary');
+  }
+  
+  if (args?.release === 'production') {
+    await replace_in_files(process.cwd(), {
+      match: [/\.js$/],
+      exclude: [/node_modules/],
+      replace_regex: /(@joystick\.js\/node-canary)/g,
+      replace_with: '@joystick.js/node',
+    });
+
+    await replace_in_files(process.cwd(), {
+      match: [/\.js$/],
+      exclude: [/node_modules/],
+      replace_regex: /(@joystick.js\/ui-canary)/g,
+      replace_with: '@joystick.js/ui',
+    });
+    
+    loader.print('Swapping canary packages for production versions...');
+    
+    await exec('npm uninstall @joystick.js/node-canary && npm i @joystick.js/node');
+    await exec('npm uninstall @joystick.js/ui-canary && npm i @joystick.js/ui');
+  }
+};
+
+export default use;

package/src/lib/build/browser_path_exclusions.js

@@ -0,0 +1,8 @@
+import get_platform_safe_path from "./get_platform_safe_path.js";
+
+const browser_path_exclusions = [
+  get_platform_safe_path("lib/node"),
+  get_platform_safe_path("tests/"),
+];
+
+export default browser_path_exclusions;

package/src/lib/build/browser_paths.js

@@ -0,0 +1,11 @@
+import get_platform_safe_path from "../get_platform_safe_path.js";
+
+const browser_paths = [
+  get_platform_safe_path("email/"),
+  get_platform_safe_path("lib/"),
+  get_platform_safe_path("lib/browser"),
+  get_platform_safe_path("ui/"),
+  "index.client.js",
+];
+
+export default browser_paths;

package/src/lib/build/build_files.js

@@ -0,0 +1,163 @@
+import esbuild from "esbuild";
+import svg from "esbuild-plugin-svg";
+import build_plugins from "./plugins/index.js";
+import get_code_frame from "./get_code_frame.js";
+import minify_file from "../build/minify_file.js";
+import on_warn from "./on_warn.js";
+import path_exists from '../path_exists.js';
+
+const handle_build_exception = async (exception = {}, file = '') => {
+  const error = exception?.errors && exception?.errors[0];
+  const snippet = await path_exists(file) ? await get_code_frame(file, {
+    line: error?.location?.line,
+    column: error?.location?.column,
+  }) : null;
+
+  await on_warn({
+    file,
+    stack: exception?.stack,
+    line: error?.location?.line,
+    column: error?.location?.column,
+    snippet,
+    lineWithError: error?.location?.lineText?.trim(),
+    message: error?.text,
+  });
+
+  return snippet;
+};
+
+const handle_parse_file_path_from_exception = (exception = {}) => {
+  const raw_error_message = exception?.message?.split(':');
+
+  // NOTE: If the build error pertains to a file that esbuild CANNOT build, the
+  // structure of the error is slightly different, placing the file(s) w/ errors
+  // after the string "files:" (which lands at index 3 in the split array).
+  if (raw_error_message[2] && raw_error_message[2]?.includes('No loader')) {
+    return raw_error_message[3] && raw_error_message[3]?.replace('\n', '') || '';
+  }
+
+  // NOTE: IF the build error is just a syntax error, the offending file will be
+  // palced at index 1.
+  return raw_error_message[1] && raw_error_message[1]?.replace('\n', '') || '';
+};
+
+const handle_build_failure = async (exception = {}) => {
+  const file = handle_parse_file_path_from_exception(exception);
+  const snippet = await handle_build_exception(exception, file);
+  
+  return {
+    success: false,
+    path: file,
+    error: {
+      stack: exception?.stack,
+      snippet,
+    },
+  };
+};
+
+const handle_build_for_node = (node_paths = [], options = {}) => {
+  return esbuild.build({
+    allowOverwrite: true,
+    platform: "node",
+    format: "esm",
+    bundle: false,
+    sourcemap: true,
+    entryPoints: node_paths?.map((file) => file.path),
+    entryNames: '[dir]/[name]',
+    outdir: options?.output_path || "./.joystick/build",
+    outbase: './',
+    define: {
+      "process.env.NODE_ENV": `'${options?.environment || 'development'}'`,
+    },
+    logLevel: "silent",
+    plugins: [
+      build_plugins.warn_node_environment,
+      build_plugins.generate_file_dependency_map
+    ],
+  });
+};
+
+const handle_build_for_browser = (browser_paths = [], options = {}) => {
+  return esbuild.build({
+    allowOverwrite: true,
+    target: "es2020",
+    platform: "browser",
+    format: "esm",
+    bundle: true,
+    sourcemap: true,
+    entryPoints: browser_paths?.map((file) => file.path),
+    entryNames: '[dir]/[name]',
+    outbase: './',
+    outdir: options?.output_path || "./.joystick/build",
+    define: {
+      "process.env.NODE_ENV": `'${options?.environment || 'development'}'`,
+    },
+    logLevel: 'silent',
+    loader: {
+      '.svg': 'text',
+    },
+    plugins: [
+      build_plugins.warn_node_environment,
+      build_plugins.generate_file_dependency_map,
+      build_plugins.bootstrap_component,
+      svg(),
+    ]
+  });
+};
+
+const build_files = async (options) => {
+  const dirty_files = ['.DS_Store'];
+  
+  const node_files = options?.files?.filter((file) => {
+    return !dirty_files?.some((dirty_file) => {
+      return file?.path?.includes(dirty_file);
+    });
+  })?.filter((file) => file?.platform === 'node');
+
+  const browser_files = options?.files?.filter((file) => {
+    return !dirty_files?.some((dirty_file) => {
+      return file?.path?.includes(dirty_file);
+    });
+  })?.filter((file) => file?.platform === 'browser');
+  
+  let node_file_results = [];
+  let browser_file_results = [];
+
+  if (node_files?.length > 0) {
+    node_file_results = [await handle_build_for_node(node_files, options)
+      .then(() => {
+        return { success: true };
+      }).catch((exception) => handle_build_failure(exception))];
+  }
+
+  if (browser_files?.length > 0) {
+    browser_file_results = [await handle_build_for_browser(browser_files, options)
+      .then(() => {
+        return { success: true };
+      }).catch((exception) => handle_build_failure(exception))];
+  }
+
+  const node_files_have_errors = node_file_results?.some((node_file_result) => !node_file_result?.success);
+  const browser_files_have_errors = browser_file_results?.some((browser_file_result) => !browser_file_result?.success);
+
+  if (node_files_have_errors || browser_files_have_errors) {
+    return Promise.reject([
+      ...node_file_results,
+      ...browser_file_results,
+    ]);
+  }
+  
+  if (options?.environment && options?.environment !== 'development') {
+    await Promise.all([...browser_files, ...node_files].map((file) => {
+      return minify_file(`${options?.output_path || "./.joystick/build"}/${file.path}`);
+    })); 
+  }
+  
+  return [
+    ...node_file_results,
+    ...browser_file_results,
+  ];
+};
+
+export default build_files;
+

package/src/{functions/start/filesToCopy.js → lib/build/copy_paths.js}

@@ -1,8 +1,8 @@
-export default [
-  { path: "css", regex: new RegExp(/^css\//) },
-  { path: "i18n", regex: new RegExp(/^i18n\//) },
-  { path: "public", regex: new RegExp(/^public\//) },
-  { path: "private", regex: new RegExp(/^private\//) },
+const copy_paths = [
+  { path: "css", regex: new RegExp(process.platform === 'win32' ? /^css\\/ : /^css\//) },
+  { path: "i18n", regex: new RegExp(process.platform === 'win32' ? /^i18n\\/ : /^i18n\//) },
+  { path: "public", regex: new RegExp(process.platform === 'win32' ? /^public\\/ : /^public\//) },
+  { path: "private", regex: new RegExp(process.platform === 'win32' ? /^private\\/ : /^private\//) },
   { path: "index.html", regex: new RegExp(/^index.html/) },
   { path: "index.css", regex: new RegExp(/^index.css/) },
   { path: "package.json", regex: new RegExp(/^package.json/) },
@@ -13,3 +13,5 @@ export default [
   { path: "settings.production.json", regex: new RegExp(/^settings.production.json/) },
   { path: ".html", regex: new RegExp(/^([0-9a-zA-Z-._])+.html/) },
 ];
+
+export default copy_paths;

package/src/lib/build/get_code_frame.js

@@ -0,0 +1,11 @@
+import fs from 'fs';
+import { codeFrameColumns } from "@babel/code-frame";
+
+const { readFile } = fs.promises;
+
+const get_code_frame = async (path = "", location = {}) => {
+  const file = await readFile(path, "utf-8");
+  return codeFrameColumns(file, { start: location });
+};
+
+export default get_code_frame;

package/src/lib/build/get_file_operation.js

@@ -0,0 +1,25 @@
+import copy_paths from "./copy_paths.js";
+
+const check_if_is_copy_path = (path = '') => {
+  return copy_paths.some((file_to_copy) => {
+    return file_to_copy.regex.test(path);
+  });
+};
+
+const check_if_is_javascript = (file_extension = '') => {
+	return file_extension === 'js';
+};
+
+const get_file_operation = (path = '') => {
+	const file_extension = path?.split('.')?.pop();
+	const is_javascript = check_if_is_javascript(file_extension);
+	const is_copy_path = check_if_is_copy_path(path);
+
+	if (!is_javascript || (is_javascript && is_copy_path)) {
+		return 'copy_file';
+	}
+
+	return 'build_file';
+};
+
+export default get_file_operation;

package/src/lib/build/get_files_to_build.js

@@ -0,0 +1,41 @@
+import fs from "fs";
+import get_files_in_path from "../get_files_in_path.js";
+import master_ignore_list from "./master_ignore_list.js";
+
+const { stat } = fs.promises;
+
+const get_files_to_build = async (excluded_paths = [], custom_copy_paths = []) => {
+  const files = await get_files_in_path("./", []);
+
+  const master_ignore_list_filtered_for_context = master_ignore_list;
+
+  const filtered_files = files
+    .filter((path) => {
+      const is_custom_copy_path = custom_copy_paths.some((custom_copy_path) => {
+        return path.includes(custom_copy_path);
+      });
+
+      return !is_custom_copy_path;
+    })
+    .filter((path) => {
+      const is_excluded = excluded_paths.some((excluded_path) => {
+        return path.includes(excluded_path);
+      });
+
+      return !is_excluded;
+    })
+    .filter((path) => {
+      const is_excluded = master_ignore_list_filtered_for_context.some((excluded_path) => {
+        return path.includes(excluded_path);
+      });
+
+      return !is_excluded;
+    })
+    .filter((path) => {
+      return !fs.lstatSync(path).isDirectory();
+    });
+
+  return filtered_files;
+};
+
+export default get_files_to_build;

package/src/lib/build/get_path_platform.js

@@ -0,0 +1,32 @@
+import browser_path_exclusions from "./browser_path_exclusions.js";
+import browser_paths from "./browser_paths.js";
+import node_paths from "./node_paths.js";
+
+const check_if_node_path = (path = '') => {
+	return node_paths.some((node_path) => {
+    return path.includes(node_path);
+  });
+};
+
+const check_if_browser_path = (path = '') => {
+  return browser_paths.some((browser_path) => {
+    return path.includes(browser_path);
+  }) && !browser_path_exclusions.some((browser_path_exclusion) => {
+    return path.includes(browser_path_exclusion);
+  });
+};
+
+const get_path_platform = (path = '') => {
+	const is_browser_path = check_if_browser_path(path);
+	const is_node_path = check_if_node_path(path);
+
+	if (is_browser_path) {
+		return 'browser';
+	}
+
+	if (is_node_path) {
+		return 'node';
+	}
+};
+
+export default get_path_platform;

package/src/lib/build/get_platform_safe_path.js

@@ -0,0 +1,6 @@
+const get_platform_safe_path = (path = '') => {
+  // NOTE: This is why serial killers exist.
+  return process.platform === 'win32' ? path.replace('/', '\\') : path;
+};
+
+export default get_platform_safe_path;

package/src/lib/build/get_tar_ignore_list.js

@@ -0,0 +1,41 @@
+import fs from "fs";
+import master_ignore_list from "./master_ignore_list.js";
+
+const get_tar_ignore_list = (excluded_paths = []) => {
+  const git_ignore = fs.existsSync(".gitignore")
+    ? fs.readFileSync(".gitignore", "utf-8")
+    : "";
+    
+  const git_ignore_files = git_ignore?.split("\n")?.filter((file) => {
+    return !file?.includes("#") && file?.trim() !== "";
+  });
+
+  // NOTE: The ^ character is an anchor to tell tar to only match the pattern
+  // to the root path. Without this, it will match all nested paths that resemble
+  // the pattern you give it. For example, ./versions will match the api/versions
+  // directory too.
+  const files_to_ignore = [
+    ...(git_ignore_files || [])?.map((ignore) => {
+      return `^${ignore}`;
+    }),
+    ...(excluded_paths || [])?.map((ignore) => {
+      return `^${ignore}`;
+    }),
+    ...(master_ignore_list || [])?.map((ignore) => {
+      return `^${ignore}`;
+    }),
+    "*.tar",
+    "*.tar.gz",
+    "*.tar.xz",
+  ]?.filter((item, itemIndex, array) => {
+    return array.indexOf(item) === itemIndex;
+  });
+
+  const exclude_list = `{${files_to_ignore
+    ?.map((file_to_ignore) => `"${file_to_ignore}"`)
+    .join(",")}}`;
+
+  return exclude_list;
+};
+
+export default get_tar_ignore_list;

package/src/lib/build/index.js

@@ -0,0 +1,137 @@
+import chalk from "chalk";
+import child_process from "child_process";
+import fs from 'fs';
+import { dirname } from 'path';
+import util from 'util';
+import build_files from "./build_files.js";
+import get_files_to_build from "./get_files_to_build.js";
+import get_file_operation from "./get_file_operation.js";
+import get_path_platform from "./get_path_platform.js";
+import get_tar_ignore_list from "./get_tar_ignore_list.js";
+import load_settings from "../load_settings.js";
+import Loader from "../loader.js";
+import path_exists from "../path_exists.js";
+import encrypt_buffer from '../../lib/encrypt_buffer.js';
+
+const { mkdir, copyFile, readFile, writeFile, readdir } = fs.promises;
+const exec = util.promisify(child_process.exec);
+
+const get_custom_copy_paths = async (copy_paths_from_settings = []) => {
+  const custom_copy_paths = [];
+
+  for (let i = 0; i < copy_paths_from_settings?.length; i += 1) {
+    const custom_copy_path = copy_paths_from_settings[i];
+
+    if (fs.existsSync(custom_copy_path)) {
+      const stat = fs.lstatSync(custom_copy_path);
+
+      if (stat.isDirectory()) {
+        const paths = await readdir(custom_copy_path, { recursive: true });
+        custom_copy_paths.push(
+          ...(paths || [])?.map((path) => {
+            return `${custom_copy_path}/${path}`;
+          })
+        );
+      } else {
+        custom_copy_paths.push(custom_copy_path);
+      }
+    }
+  }
+
+  return custom_copy_paths;
+};
+
+const get_files_to_build_with_operation_and_platform = (files = []) => {
+  return files?.map((file) => {
+    return {
+      path: file,
+      operation: get_file_operation(file),
+      platform: get_path_platform(file),
+    }
+  });
+};
+
+const build = async (options = {}) => {
+  const loader = new Loader();
+
+  const build_type = options?.type || 'tar';
+  const environment = options?.environment || "production";
+
+  loader.print(`Building app to ${build_type} for ${environment}...`);
+
+  const settings = await load_settings(environment);
+  const excluded_paths = settings?.config?.build?.excluded_paths || settings?.config?.build?.excludedPaths;
+  const custom_copy_paths = await get_custom_copy_paths(settings?.config?.build?.copy_paths);
+
+  const files_for_build = await get_files_to_build(excluded_paths, custom_copy_paths);
+  const output_path = build_type === 'tar' ? '.build/.tar' : '.build';
+  const files_to_build_with_operation_and_platform = get_files_to_build_with_operation_and_platform(files_for_build);
+
+  if (await path_exists('.build')) {
+    await exec(`rm -rf .build`);
+  }
+
+  const files_to_copy = [
+    ...files_to_build_with_operation_and_platform?.filter((file) => {
+      return file?.operation === 'copy_file';
+    }),
+    ...(custom_copy_paths || [])?.map((custom_copy_path) => {
+      return { path: custom_copy_path };
+    }),
+  ];
+
+  const files_to_build = files_to_build_with_operation_and_platform?.filter((file) => {
+    return file?.operation === 'build_file';
+  });
+
+  for (let i = 0; i < files_to_copy?.length; i += 1) {
+    const file_to_copy = files_to_copy[i];
+    const stat = fs.lstatSync(file_to_copy?.path);
+
+    if (stat.isFile()) {
+      await mkdir(dirname(`${output_path}/${file_to_copy?.path}`), { recursive: true });
+      await copyFile(file_to_copy?.path, `${output_path}/${file_to_copy?.path}`);
+    }
+  }
+
+  await build_files({
+    files: files_to_build,
+    environment,
+    output_path,
+  }).catch((error) => {
+    console.warn(error);
+  });
+
+  if (build_type === "tar") {
+    const ignore_list = get_tar_ignore_list(settings?.config?.build?.excludedPaths);
+
+    await exec(
+      `cd ${output_path} && tar --exclude=${ignore_list} -czf ../build.tar.gz .`
+    );
+
+    await exec(`rm -rf ${output_path}`);
+  }
+
+  if (build_type === "tar" && options?.encrypt_build) {
+    const build_path = output_path?.replace('/.tar', '/build.tar.gz');
+
+    const encrypted_build = encrypt_buffer(
+      await readFile(build_path),
+      options?.encryption_key,
+    );
+
+    await writeFile(`.build/build.encrypted.tar.gz`, encrypted_build);
+  }
+
+  if (!options?.silence_confirmation) {
+    console.log(
+      chalk.greenBright(`\n✔ App built as ${build_type} to ${build_type === 'tar' ? output_path?.replace('/.tar', '/build.tar.gz') : output_path}!\n`)
+    );
+  }
+
+  if (await path_exists('.build/component_id_cache.json')) {
+    await exec(`rm -rf .build/component_id_cache.json`);
+  }
+};
+
+export default build;