@apollion-dsi/scripts 0.7.7

package/src/utils/WebpackDevServerUtils.ts

@@ -0,0 +1,179 @@
+import os from 'os';
+import url from 'url';
+
+import chalk from 'chalk';
+
+import formatWebpackMessages from './formatWebpackMessages';
+
+// detect-port@2 is ESM-only; load lazily via native dynamic import so we stay CJS-compatible.
+// Wrapped in Function() so TypeScript's CommonJS emitter doesn't downlevel it to require().
+const dynamicImport = new Function('specifier', 'return import(specifier)') as (specifier: string) => Promise<any>;
+
+async function detectPort(port: number): Promise<number> {
+  const mod: any = await dynamicImport('detect-port');
+  const fn = mod.default ?? mod.detect ?? mod;
+  return fn(port);
+}
+
+export type PreparedUrls = {
+  lanUrlForConfig?: string;
+  lanUrlForTerminal?: string;
+  localUrlForTerminal: string;
+  localUrlForBrowser: string;
+};
+
+function getLanIp(): string | undefined {
+  const ifaces = os.networkInterfaces();
+  for (const name of Object.keys(ifaces)) {
+    const list = ifaces[name];
+    if (!list) continue;
+    for (const iface of list) {
+      if (iface.family === 'IPv4' && !iface.internal) {
+        return iface.address;
+      }
+    }
+  }
+  return undefined;
+}
+
+function formatUrl(protocol: string, hostname: string, port: number, pathname: string): string {
+  return url.format({
+    protocol,
+    hostname,
+    port,
+    pathname: pathname || '/',
+  });
+}
+
+export function prepareUrls(protocol: string, host: string, port: number, pathname: string = '/'): PreparedUrls {
+  const isUnspecifiedHost = host === '0.0.0.0' || host === '::';
+  let prettyHost = host;
+  let lanUrlForConfig: string | undefined;
+  let lanUrlForTerminal: string | undefined;
+
+  if (isUnspecifiedHost) {
+    prettyHost = 'localhost';
+    const lanIp = getLanIp();
+    if (lanIp) {
+      lanUrlForConfig = lanIp;
+      lanUrlForTerminal = formatUrl(protocol, lanIp, port, pathname);
+    }
+  }
+
+  const localUrlForTerminal = formatUrl(protocol, prettyHost, port, pathname);
+  const localUrlForBrowser = formatUrl(protocol, prettyHost, port, pathname);
+
+  return {
+    lanUrlForConfig,
+    lanUrlForTerminal,
+    localUrlForTerminal,
+    localUrlForBrowser,
+  };
+}
+
+export async function choosePort(_host: string, defaultPort: number): Promise<number | null> {
+  try {
+    const port = await detectPort(defaultPort);
+    if (port === defaultPort) return port;
+    console.log(chalk.yellow(`Port ${defaultPort} is in use; using ${port} instead.`));
+    return port;
+  } catch (err) {
+    console.error(chalk.red(`Could not find a free port.`), err);
+    return null;
+  }
+}
+
+type PrepareProxyResult = any[] | undefined;
+
+export function prepareProxy(proxy: unknown, _appPublicFolder?: string, _servedPathname?: string): PrepareProxyResult {
+  if (!proxy) return undefined;
+
+  if (typeof proxy === 'string') {
+    return [
+      {
+        context: (pathname: string) => {
+          return pathname !== '/' && !pathname.startsWith('/sockjs-node') && !pathname.startsWith('/ws');
+        },
+        target: proxy,
+        changeOrigin: true,
+        secure: false,
+      },
+    ];
+  }
+
+  if (Array.isArray(proxy)) return proxy;
+
+  // proxy as object (legacy CRA shape: { "/api": { target: ... } })
+  if (typeof proxy === 'object') {
+    return Object.entries(proxy as Record<string, any>).map(([context, value]) => {
+      if (value && typeof value === 'object') {
+        return { context: [context], ...value };
+      }
+      return { context: [context], target: value };
+    });
+  }
+
+  return undefined;
+}
+
+export type CreateCompilerOptions = {
+  appName: string;
+  config: any;
+  urls: PreparedUrls;
+  useYarn?: boolean;
+  useTypeScript?: boolean;
+  tscCompileOnError?: boolean;
+  webpack: any;
+  devSocket?: unknown;
+};
+
+export function createCompiler({ appName, config, urls, webpack }: CreateCompilerOptions): any {
+  let compiler;
+  try {
+    compiler = webpack(config);
+  } catch (err) {
+    console.log(chalk.red('Failed to compile.'));
+    console.log();
+    console.log((err as Error).message || err);
+    console.log();
+    process.exit(1);
+  }
+
+  compiler.hooks.invalid.tap('invalid', () => {
+    console.log();
+    console.log('Compiling...');
+  });
+
+  compiler.hooks.done.tap('done', (stats: any) => {
+    const statsData = stats.toJson({ all: false, warnings: true, errors: true });
+    const messages = formatWebpackMessages(statsData);
+    const isSuccessful = !messages.errors.length && !messages.warnings.length;
+
+    if (isSuccessful) {
+      console.log(chalk.green(`Compiled successfully!`));
+      console.log();
+      console.log(`You can now view ${chalk.bold(appName)} in the browser.`);
+      if (urls.lanUrlForTerminal) {
+        console.log(`  ${chalk.bold('Local:')}            ${urls.localUrlForTerminal}`);
+        console.log(`  ${chalk.bold('On Your Network:')}  ${urls.lanUrlForTerminal}`);
+      } else {
+        console.log(`  ${urls.localUrlForTerminal}`);
+      }
+      return;
+    }
+
+    if (messages.errors.length) {
+      if (messages.errors.length > 1) messages.errors.length = 1;
+      console.log(chalk.red('Failed to compile.\n'));
+      console.log(messages.errors.join('\n\n'));
+      return;
+    }
+
+    if (messages.warnings.length) {
+      console.log(chalk.yellow('Compiled with warnings.\n'));
+      console.log(messages.warnings.join('\n\n'));
+    }
+  });
+
+  return compiler;
+}

package/src/utils/checkRequiredFiles.ts

@@ -0,0 +1,22 @@
+import fs from 'fs';
+import path from 'path';
+
+import chalk from 'chalk';
+
+export default function checkRequiredFiles(files: string[]): boolean {
+  let currentFilePath: string | undefined;
+  try {
+    files.forEach((filePath) => {
+      currentFilePath = filePath;
+      fs.accessSync(filePath, fs.constants.F_OK);
+    });
+    return true;
+  } catch (err) {
+    const dirName = currentFilePath ? path.dirname(currentFilePath) : '';
+    const fileName = currentFilePath ? path.basename(currentFilePath) : '';
+    console.log(chalk.red('Could not find a required file.'));
+    console.log(`  ${chalk.red('Name')}: ${chalk.cyan(fileName)}`);
+    console.log(`  ${chalk.red('Searched in')}: ${chalk.cyan(dirName)}`);
+    return false;
+  }
+}

package/src/utils/devServerMiddleware.ts

@@ -0,0 +1,20 @@
+import type { IncomingMessage, ServerResponse } from 'http';
+
+type NextFn = (err?: unknown) => void;
+type Middleware = (req: IncomingMessage, res: ServerResponse, next: NextFn) => void;
+
+export function evalSourceMapMiddleware(_devServer?: unknown): Middleware {
+  return (_req, _res, next) => next();
+}
+
+export function ignoredFiles(appSrc: string): RegExp {
+  return new RegExp(`^(?!${appSrc}).+/node_modules/`, 'i');
+}
+
+export function noopServiceWorkerMiddleware(_servedPath?: string): Middleware {
+  return (_req, _res, next) => next();
+}
+
+export function redirectServedPathMiddleware(_servedPath?: string): Middleware {
+  return (_req, _res, next) => next();
+}

package/src/utils/formatWebpackMessages.ts

@@ -0,0 +1,30 @@
+export type FormattedMessages = {
+  errors: string[];
+  warnings: string[];
+};
+
+function toString(item: unknown): string {
+  if (item == null) return '';
+  if (typeof item === 'string') return item;
+  if (typeof item === 'object') {
+    const anyItem = item as any;
+    if (typeof anyItem.message === 'string') {
+      let result = '';
+      if (anyItem.moduleName) result += `in ${anyItem.moduleName}\n\n`;
+      result += anyItem.message;
+      return result;
+    }
+    try {
+      return JSON.stringify(anyItem);
+    } catch {
+      return String(anyItem);
+    }
+  }
+  return String(item);
+}
+
+export default function formatWebpackMessages(json: any): FormattedMessages {
+  const errors = Array.isArray(json?.errors) ? json.errors.map(toString) : [];
+  const warnings = Array.isArray(json?.warnings) ? json.warnings.map(toString) : [];
+  return { errors, warnings };
+}

package/src/utils/getPublicUrlOrPath.ts

@@ -0,0 +1,39 @@
+import { URL } from 'url';
+
+export default function getPublicUrlOrPath(
+  isEnvDevelopment: boolean,
+  homepage: string | undefined,
+  envPublicUrl: string | undefined,
+): string {
+  const stubDomain = 'https://create-react-app.dev';
+
+  if (envPublicUrl) {
+    let normalized = envPublicUrl;
+    if (!normalized.endsWith('/')) normalized += '/';
+    try {
+      const validPublicUrl = new URL(normalized, stubDomain);
+      return isEnvDevelopment ? (normalized.startsWith('.') ? '/' : validPublicUrl.pathname) : normalized;
+    } catch {
+      return normalized;
+    }
+  }
+
+  if (homepage) {
+    let normalized = homepage;
+    if (!normalized.endsWith('/')) normalized += '/';
+    try {
+      const validHomepagePathname = new URL(normalized, stubDomain).pathname;
+      return isEnvDevelopment
+        ? normalized.startsWith('.')
+          ? '/'
+          : validHomepagePathname
+        : normalized.startsWith('.')
+          ? normalized
+          : validHomepagePathname;
+    } catch {
+      return normalized;
+    }
+  }
+
+  return '/';
+}

package/src/utils/printBuildError.ts

@@ -0,0 +1,8 @@
+export default function printBuildError(err: unknown): void {
+  if (err instanceof Error) {
+    console.error(err.message);
+    if (err.stack) console.error(err.stack);
+  } else {
+    console.error(err);
+  }
+}

package/src/utils/printHostingInstructions.ts

@@ -0,0 +1,12 @@
+import chalk from 'chalk';
+
+export default function printHostingInstructions(
+  _appPackage: unknown,
+  _publicUrl: string,
+  _publicPath: string | undefined,
+  buildFolder: string,
+  _useYarn: boolean,
+): void {
+  console.log(`The build is ready in the ${chalk.cyan(buildFolder)} folder.`);
+  console.log('You may serve it with any static file server.');
+}

package/template/.editorconfig

@@ -0,0 +1,43 @@
+# top-most EditorConfig file
+root = true
+
+# Unix-style newlines with a newline ending every file
+[**]
+end_of_line = lf
+insert_final_newline = true
+
+# Standard at: https://github.com/felixge/node-style-guide
+[**.{js,jsx,ts,tsx,json}]
+trim_trailing_whitespace = true
+indent_style = space
+indent_size = 2
+quote_type = single
+curly_bracket_next_line = false
+spaces_around_operators = true
+space_after_control_statements = true
+space_after_anonymous_functions = true
+spaces_in_brackets = false
+
+# No Standard.  Please document a standard if different from .js
+[**.{yml,css}]
+trim_trailing_whitespace = true
+indent_style = tab
+
+[**.html]
+trim_trailing_whitespace = true
+indent_style = space
+indent_size = 2
+
+# No standard.  Please document a standard if different from .js
+[**.md]
+indent_style = tab
+
+# Standard at:
+[Makefile]
+indent_style = tab
+
+# The indentation in package.json will always need to be 2 spaces
+# https://github.com/npm/npm/issues/4718
+[{package, bower}.json]
+indent_style = space
+indent_size = 2

package/template/.prettierignore

@@ -0,0 +1,6 @@
+package.json
+node_modules
+build
+lib
+coverage
+/.vscode

package/template/.prettierrc.js

@@ -0,0 +1 @@
+module.exports = require('@apollion-dsi/eslint-config/prettier.config');

package/template/audit-ci.json

@@ -0,0 +1,5 @@
+{
+  "high": true,
+  "package-manager": "yarn",
+  "report-type": "summary"
+}

package/template/commitlint.config.js

@@ -0,0 +1 @@
+module.exports = { extends: ['@commitlint/config-conventional'] };

package/template/eslint.config.js

@@ -0,0 +1,3 @@
+const sharedConfig = require('@apollion-dsi/eslint-config');
+
+module.exports = [...sharedConfig];

package/template/jest.config.js

@@ -0,0 +1,4 @@
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'jsdom',
+};

package/template/public/index.html

@@ -0,0 +1,20 @@
+<!DOCTYPE html>
+<html lang="pt-br">
+  <head>
+    <meta charset="utf-8" />
+    <base href="/" />
+    <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1" />
+    <meta name="viewport" content="width=device-width,initial-scale=1,shrink-to-fit=no,user-scalable=no" />
+    <meta name="description" content="Código gerado usando 'Apollion Scripts'" />
+    <link data-react-helmet="true" rel="shortcut icon" href="https://apollion.captalysplatform.io/img/favicon.ico" />
+    <link
+      href="https://fonts.googleapis.com/css2?family=Mulish:ital,wght@0,300;0,400;0,600;0,900;1,300;1,400;1,600;1,900&display=swap"
+      rel="stylesheet"
+    />
+    <title>Apollion Framework</title>
+  </head>
+  <body>
+    <noscript>Ative o JavaScript em seu navegador para visualizar este Web Site</noscript>
+    <div id="root"></div>
+  </body>
+</html>

package/template/src/App.test.tsx

@@ -0,0 +1,10 @@
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import { Root } from './App';
+
+test('renders the button', () => {
+  const { getByTestId } = render(<Root />);
+
+  expect(getByTestId('notify_button')).toHaveTextContent('Aperte Aqui');
+});

package/template/src/App.tsx

@@ -0,0 +1,35 @@
+import { ApollionProvider, Button, Flex, GlobalStyle, Text, useNotification } from '@apollion-dsi/core';
+import React from 'react';
+
+function App() {
+  const { showNotification } = useNotification();
+
+  return (
+    <Flex gap="giant" p="giant">
+      <Text textAlign="center" variant="h2" color="warning.dark">
+        Ola, <Text color="main">Mundo</Text>
+      </Text>
+
+      <Button
+        data-testid="notify_button"
+        text="Aperte Aqui"
+        onClick={() => {
+          showNotification({
+            title: 'kkkkk',
+            message: 'ERRRROOOUUUUUUUUU',
+            autoClose: 10,
+          });
+        }}
+      />
+    </Flex>
+  );
+}
+
+export function Root() {
+  return (
+    <ApollionProvider>
+      <GlobalStyle />
+      <App />
+    </ApollionProvider>
+  );
+}

package/template/src/index.tsx

@@ -0,0 +1,10 @@
+import React from 'react';
+import { render } from 'react-dom';
+import { Root } from './App';
+
+render(
+  <React.StrictMode>
+    <Root />
+  </React.StrictMode>,
+  document.getElementById('root'),
+);

package/template/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "target": "es5",
+    "lib": [
+      "dom",
+      "dom.iterable",
+      "esnext"
+    ],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "strict": true,
+    "forceConsistentCasingInFileNames": true,
+    "module": "esnext",
+    "moduleResolution": "node",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "react"
+  },
+  "include": [
+    "src"
+  ]
+}

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "include": ["src"],
+  "exclude": ["./src/template"],
+  "compilerOptions": {
+    "outDir": "lib",
+    "rootDir": "src",
+    "module": "node16",
+    "target": "es2020",
+    "moduleResolution": "node16",
+    "declaration": true,
+    "esModuleInterop": true,
+    "strict": true,
+    "sourceMap": true,
+    "noImplicitAny": false,
+    "skipLibCheck": true,
+    "allowJs": true
+  }
+}