@soleil-se/build-app 1.0.0

package/README.md

@@ -0,0 +1,5 @@
+# @soleil-se/build-app
+
+Script for building WebApps, RESTApps and Widgets with Svelte in Sitevision.
+
+[Documentation](https://docs.soleil.se/build/app) | [Changelog](https://docs.soleil.se/build/app/changelog)

package/bin/index.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+import '../index.js';

package/config/index.js

@@ -0,0 +1,26 @@
+import { client, server } from '../rollup/index.js';
+import copy from '../utils/copy.js';
+import configFiles from '../utils/configFiles.js';
+
+export default function config({ src, dest, cache }) {
+  if (src) {
+    return [
+      copy({ src: `${src}/index.html`, dest }),
+      copy({ src: `${src}/config.css`, dest }),
+      server({
+        input: `${src}/index.js`,
+        output: `${dest}/index.js`,
+      }),
+      client({
+        input: `${src}/config.js`,
+        output: `${dest}/config.js`,
+        globals: { jquery: 'jQuery' },
+        showSize: false,
+        hydratable: false,
+        cache,
+      }),
+      configFiles({ dest }),
+    ];
+  }
+  return undefined;
+}

package/config.js

@@ -0,0 +1,69 @@
+import config from '@soleil-se/build-config';
+
+import fse from 'fs-extra';
+import { createRequire } from 'module';
+import { dirname } from 'path';
+
+const require = createRequire(import.meta.url);
+
+function readManifestFile() {
+  if (fse.existsSync('./manifest.json')) return fse.readJsonSync('./manifest.json');
+  if (fse.existsSync('./src/manifest.json')) return fse.readJsonSync('./src/manifest.json');
+  return {};
+}
+
+function getClientInput() {
+  if (fse.existsSync('./src/main.js')) return './src/main.js';
+  if (fse.existsSync('./app_src/main.js')) return './app_src/main.js';
+  return false;
+}
+
+function getServerInput() {
+  if (fse.existsSync('./src/index.js')) return './src/index.js';
+  if (fse.existsSync('./app_src/index.js')) return './app_src/index.js';
+  return false;
+}
+
+function getHooksInput() {
+  if (fse.existsSync('./src/hooks.js')) return './src/hooks.js';
+  if (fse.existsSync('./app_src/hooks.js')) return './app_src/hooks.js';
+  return false;
+}
+
+function getConfigInput() {
+  if (fse.existsSync('./config')) return './config';
+  if (fse.existsSync('./app_config')) return './app_config';
+  return false;
+}
+
+function getGlobalConfigInput() {
+  if (fse.existsSync('./config_global')) return './config_global';
+  if (fse.existsSync('./app_config_global')) return './app_config_global';
+  return false;
+}
+
+export const { env, projectRoot, rollup } = config;
+export const manifest = readManifestFile();
+export const type = manifest.type.toLowerCase();
+export const input = {
+  client: getClientInput(),
+  server: getServerInput(),
+  hooks: getHooksInput(),
+  config: getConfigInput(),
+  globalConfig: getGlobalConfigInput(),
+};
+
+const folders = [
+  input.client && dirname(input.client),
+  input.server && dirname(input.server),
+  input.hooks && dirname(input.hooks),
+  input.config,
+  input.globalConfig,
+]
+  .filter((folder) => !!folder)
+  .filter((v, i, arr) => arr.indexOf(v) === i);
+
+export const watchPaths = folders.map((folder) => `${folder}/**/*`).concat('./manifest.json');
+export const eslintPaths = folders.map((folder) => `${folder}/**/*.{js,svelte}`);
+
+export const { version: buildVersion } = require('./package.json');

package/index.js

@@ -0,0 +1,94 @@
+import args from '@soleil-se/build-utils/args';
+import runTasks from '@soleil-se/build-utils/runTasks';
+import task from '@soleil-se/build-utils/task';
+import watch from '@soleil-se/build-utils/watch';
+import { getTimestamp, logError, logInfo } from '@soleil-se/build-utils/log';
+import chalk from 'chalk';
+
+import {
+  input, type, manifest, env, projectRoot, buildVersion, rollup, watchPaths, eslintPaths,
+} from './config.js';
+
+import { clean, copy, files, zip, eslint } from './utils/index.js';
+import { client, server } from './rollup/index.js';
+import { activate, upload, sign } from './requests/index.js';
+import config from './config/index.js';
+
+const cssOutput = type === 'webapp' ? './dist/src/css/app.css' : './dist/src/resource/client/app.css';
+const zipPath = `./dist/${manifest.id}-${manifest.version}.zip`;
+
+async function main() {
+  console.log(getTimestamp(), `${manifest.name} (${manifest.id})`);
+  console.log(getTimestamp(), chalk.green('Starting'), '@soleil-se/sv-app-build', chalk.green('version'), chalk.green(chalk.underline(buildVersion)));
+  logInfo(`Using ${chalk.white('project_config.json')} in ${chalk.white(projectRoot)}`);
+  const tasks = [
+    task('clean', clean({ dir: './dist' })),
+    args.eslint && task('eslint', eslint({ src: eslintPaths })),
+    task('copy', [
+      copy({ src: './manifest.json', dest: './dist/src' }),
+      copy(manifest.bundled || input.server?.startsWith('./src')
+        ? { src: ['./src/manifest.json', './src/appDataDefaults.json', './src/i18n', './src/config', './src/resource'], dest: './dist/src' }
+        : { src: ['./src'], dest: './dist' }),
+    ]),
+    task('server', server({
+      input: input.server,
+      output: './dist/src/index.js',
+      debug: args.debug,
+      bundled: manifest.bundled,
+      cache: args.cache,
+      cssOutput,
+    })),
+    task('client', client({
+      input: input.client,
+      output: manifest.bundled ? './dist/src/main.js' : './dist/src/resource/client/index.js',
+      bundled: manifest.bundled,
+      globals: rollup?.client?.globals,
+      debug: args.debug,
+      cache: args.cache,
+      cssOutput,
+    })),
+    task('hooks', server({
+      input: input.hooks,
+      output: './dist/src/hooks.js',
+      bundled: manifest.bundled,
+      debug: args.debug,
+      cache: args.cache,
+      cssOutput,
+    })),
+    task('config', config({ src: input.config, dest: './dist/src/config', cache: args.cache })),
+    task('globalConfig', config({ src: input.globalConfig, dest: './dist/src/config/global', cache: args.cache })),
+    task('files', files({ type: manifest.type, dest: './dist' })),
+    task('zip', zip({ src: './dist/src', dest: zipPath })),
+  ];
+
+  if (args.sign ?? env.sign ?? env.production) {
+    tasks.push(task('sign', sign({ src: zipPath, manifest })));
+  }
+
+  if (args.sync) {
+    tasks.push(task('upload', upload({
+      src: zipPath,
+      manifest,
+      force: args.force || !env.production,
+    })));
+
+    if (args.activate) {
+      tasks.push(task('activate', activate()));
+    }
+  }
+
+  if (args.watch) {
+    watch(watchPaths, () => runTasks(tasks));
+  } else {
+    await runTasks(tasks);
+  }
+  if (args.run) await runTasks(tasks);
+}
+
+main().catch((e) => {
+  logError(e.message);
+  logError(e.stack);
+  process.exit(1);
+});
+
+process.on('unhandledRejection', () => {});

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@soleil-se/build-app",
+  "version": "1.0.0",
+  "bin": {
+    "build-app": "./bin/index.js",
+    "sv-app-build": "./bin/index.js"
+  },
+  "main": "index.js",
+  "author": "Soleil AB",
+  "license": "UNLICENSED",
+  "type": "module",
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "homepage": "https://docs.soleil.se/build/app",
+  "dependencies": {
+    "@babel/core": "7.16.12",
+    "@babel/preset-env": "7.16.11",
+    "@rollup/plugin-alias": "3.1.9",
+    "@rollup/plugin-babel": "5.3.0",
+    "@rollup/plugin-commonjs": "21.0.1",
+    "@rollup/plugin-json": "4.1.0",
+    "@rollup/plugin-node-resolve": "13.1.3",
+    "@rollup/plugin-replace": "3.0.1",
+    "@soleil-se/build-config": "1.1.1",
+    "@soleil-se/build-utils": "1.3.0",
+    "archiver": "5.3.0",
+    "autoprefixer": "^10.4.2",
+    "babel-plugin-transform-async-to-promises": "^0.8.18",
+    "chalk": "5.0.0",
+    "find-up": "6.2.0",
+    "form-data": "4.0.0",
+    "fs-extra": "10.0.0",
+    "got": "12.0.1",
+    "lodash-es": "4.17.21",
+    "postcss": "8.4.6",
+    "postcss-discard-duplicates": "^5.0.2",
+    "postcss-pxtorem": "^6.0.0",
+    "rollup": "2.66.1",
+    "rollup-plugin-cleanup": "3.2.1",
+    "rollup-plugin-filesize": "9.1.2",
+    "rollup-plugin-insert": "^1.3.2",
+    "rollup-plugin-postcss": "4.0.2",
+    "rollup-plugin-string": "3.0.0",
+    "rollup-plugin-svelte": "7.1.0",
+    "rollup-plugin-terser": "7.0.2",
+    "sass": "1.49.7",
+    "slash": "4.0.0",
+    "svelte-preprocess": "4.10.2"
+  },
+  "devDependencies": {
+    "svelte": "3.46.3"
+  },
+  "description": "Script for building WebApps, RESTApps and Widgets with Svelte in Sitevision.",
+  "keywords": [
+    "Sitevision",
+    "WebApp",
+    "RESTApp",
+    "Widget",
+    "Svelte"
+  ]
+}

package/requests/activateAddon.js

@@ -0,0 +1,53 @@
+import chalk from 'chalk';
+import fse from 'fs-extra';
+
+import { logSuccess } from '@soleil-se/build-utils/log';
+
+import addonRequest from './api/addonRequest.js';
+import handleError from './api/handleError.js';
+
+function readManifestFile() {
+  try {
+    if (fse.existsSync('./manifest.json')) {
+      return fse.readJsonSync('./manifest.json');
+    }
+    if (fse.existsSync('./src/manifest.json')) {
+      return fse.readJsonSync('./src/manifest.json');
+    }
+    throw new Error('Could not find manifest.json...');
+  } catch (e) {
+    throw new Error('Unable to parse manifest.json...');
+  }
+}
+
+function getPropertiesUri(type, id, version) {
+  switch (type.toLowerCase()) {
+    case 'webapp':
+      return `WebApp%20Repository/${id}-${version}/properties`;
+    case 'restapp':
+      return `RestApp%20Repository/${id}-${version}/properties`;
+    default:
+      throw new Error('Unknown app type...');
+  }
+}
+
+export default async function activateAddon() {
+  try {
+    const { id, version, name, type } = readManifestFile();
+
+    const { 'jcr:uuid': customModuleExecutableId } = await addonRequest({
+      url: getPropertiesUri(type, id, version),
+      method: 'GET',
+    });
+
+    await addonRequest({
+      url: `Addon%20Repository/${encodeURIComponent(name)}/activatecustommoduleexecutable`,
+      method: 'PUT',
+      searchParams: { customModuleExecutableId },
+    });
+
+    logSuccess(`${type} ${chalk.white(`${name} (${id}@${version})`)} activated successfully!`);
+  } catch (error) {
+    handleError(error);
+  }
+}

package/requests/addonExists.js

@@ -0,0 +1,13 @@
+import handleError from './api/handleError.js';
+import addonRequest from './api/addonRequest.js';
+
+export default async function addonExists({ name }) {
+  try {
+    const addons = await addonRequest('Addon%20Repository/nodes', {
+      method: 'GET',
+    });
+    return !!addons.find((addon) => addon.name === name);
+  } catch (error) {
+    return handleError(error);
+  }
+}

package/requests/api/addonRequest.js

@@ -0,0 +1,37 @@
+import got from 'got';
+import config from '@soleil-se/build-config';
+
+const { name, host, auth, acceptUnauthorizedCert } = config.env;
+
+const [username, password] = Buffer.from(auth || '', 'base64').toString().split(':');
+
+const options = {
+  prefixUrl: `${host}/rest-api/1/0/${encodeURI(name)}/`,
+  username,
+  password,
+  method: 'POST',
+  responseType: 'json',
+  resolveBodyOnly: true,
+  hooks: {
+    beforeError: [
+      (error) => {
+        const { response } = error;
+        if (response) {
+          const { body } = response;
+          let message = body && body.message ? body.message : body.toString();
+          if (!message && response.statusCode === 401) {
+            message = 'Unauthorized, correct username and password?';
+          }
+          return new Error(`${response.statusCode} - ${message}`);
+        }
+        return new Error(error.message);
+      },
+    ],
+  },
+};
+
+if (acceptUnauthorizedCert) {
+  options.https = { rejectUnauthorized: false };
+}
+
+export default got.extend(options);

package/requests/api/handleError.js

@@ -0,0 +1,23 @@
+import { HTTPError } from 'got';
+
+function handleError(error) {
+  if (error instanceof HTTPError) {
+    const { response } = error;
+    if (response.statusCode === 401) {
+      throw new Error(`${error.name}: ${response.statusCode} - Unauthorized, correct username and password?`);
+    }
+    if (response.statusCode === 500) {
+      if (response.body instanceof Buffer) {
+        const { message } = JSON.parse(response.body.toString());
+        throw new Error(`${error.name}: ${response.statusCode} - ${message}`);
+      }
+      throw new Error(`${error.name}: ${response.statusCode} - Would write some kind of proper error message if SiteVision told us what went wrong...`);
+    }
+  }
+  if (error.message === 'URI malformed') {
+    throw new Error('URI malformed - Username or password may contain special characters?');
+  }
+  throw new Error(error);
+}
+
+export default handleError;

package/requests/createAddon.js

@@ -0,0 +1,27 @@
+import chalk from 'chalk';
+import { logSuccess } from '@soleil-se/build-utils/log';
+import addonRequest from './api/addonRequest.js';
+import handleError from './api/handleError.js';
+
+function getCreateUri(type) {
+  switch (type.toLowerCase()) {
+    case 'webapp':
+      return 'Addon%20Repository/custommodule';
+    case 'restapp':
+      return 'Addon%20Repository/headlesscustommodule';
+    default:
+      throw new Error('Unknown app type...');
+  }
+}
+
+export default async function createAddon({ id, name, type, category }) {
+  try {
+    await addonRequest({
+      url: getCreateUri(type),
+      searchParams: { name, category: category || 'Other' },
+    });
+    logSuccess(`${type} ${chalk.white(`${name} (${id})`)} created successfully!`);
+  } catch (error) {
+    handleError(error);
+  }
+}

package/requests/index.js

@@ -0,0 +1,28 @@
+import addonExists from './addonExists.js';
+import createAddon from './createAddon.js';
+import uploadAddon from './uploadAddon.js';
+import activateAddon from './activateAddon.js';
+import signAddon from './signAddon.js';
+
+export function upload({ src, manifest, force }) {
+  return async () => {
+    let checkIfExists = true;
+    if (checkIfExists) {
+      const exists = await addonExists(manifest);
+      if (!exists) {
+        await createAddon(manifest);
+      }
+      checkIfExists = false;
+    }
+
+    return uploadAddon({ ...manifest, src, force });
+  };
+}
+
+export function activate() {
+  return () => activateAddon();
+}
+
+export function sign({ src, manifest }) {
+  return () => signAddon({ src, manifest });
+}

package/requests/signAddon.js

@@ -0,0 +1,44 @@
+import { basename } from 'path';
+import fse from 'fs-extra';
+import chalk from 'chalk';
+import got from 'got';
+import FormData from 'form-data';
+import { logSuccess } from '@soleil-se/build-utils/log';
+import config from '@soleil-se/build-config';
+
+import handleError from './api/handleError.js';
+
+const { certificate, auth } = config.webappSign;
+const [username, password] = Buffer.from(auth || '', 'base64').toString().split(':');
+
+function signRequest(path) {
+  const form = new FormData();
+  const filename = basename(path);
+  form.append('file', fse.createReadStream(path), {
+    filename,
+    contentType: 'application/octet-stream',
+  });
+
+  return got({
+    url: 'https://developer.sitevision.se/rest-api/appsigner/signapp',
+    method: 'POST',
+    username,
+    password,
+    searchParams: { certificateName: certificate },
+    body: form,
+    responseType: 'buffer',
+  }).buffer();
+}
+
+export default async function signAddon({ src, manifest }) {
+  try {
+    if (!fse.existsSync(src)) throw new Error(`Could not find ${src}`);
+
+    const response = await signRequest(src);
+    await fse.writeFile(src, response);
+
+    logSuccess(`${manifest.type} ${chalk.white(`${manifest.name} (${manifest.id})`)} signed successfully!`);
+  } catch (error) {
+    handleError(error);
+  }
+}

package/requests/uploadAddon.js

@@ -0,0 +1,36 @@
+import fse from 'fs-extra';
+import chalk from 'chalk';
+import FormData from 'form-data';
+import { logSuccess } from '@soleil-se/build-utils/log';
+
+import handleError from './api/handleError.js';
+import addonRequest from './api/addonRequest.js';
+
+function getUploadUri(type, name) {
+  switch (type.toLowerCase()) {
+    case 'webapp':
+      return `Addon%20Repository/${encodeURIComponent(name)}/webAppImport`;
+    case 'restapp':
+      return `Addon%20Repository/${encodeURIComponent(name)}/restAppImport`;
+    default:
+      throw new Error('Unknown app type...');
+  }
+}
+
+export default async function uploadAddon({ id, type, name, src, force }) {
+  try {
+    if (!fse.existsSync(src)) {
+      throw new Error(`Could not find ${src}`);
+    }
+    const form = new FormData();
+    form.append('file', fse.createReadStream(src));
+
+    await addonRequest(getUploadUri(type, name), {
+      searchParams: { force },
+      body: form,
+    });
+    logSuccess(`${type} ${chalk.white(`${name} (${id})`)} uploaded successfully!`);
+  } catch (error) {
+    handleError(error);
+  }
+}

package/rollup/api/common/preprocessOptions.js

@@ -0,0 +1,14 @@
+import config from '@soleil-se/build-config';
+
+const sass = {
+  includePaths: [`${config.projectRoot}/client_src/sass`],
+};
+
+export default {
+  sass,
+  scss: sass,
+  less: {
+    paths: [`${config.projectRoot}/client_src/less`],
+  },
+  postcss: false,
+};

package/rollup/api/getAliasPlugin.js

@@ -0,0 +1,32 @@
+import path from 'path';
+import alias from '@rollup/plugin-alias';
+import config from '@soleil-se/build-config';
+
+const resolveAlias = (root, aliases = {}) => Object.entries(aliases)
+  .reduce((acc, [key, value]) => ({
+    ...acc,
+    [key]: path.resolve(root, value),
+  }), {});
+
+const clientAlias = resolveAlias(config.projectRoot, {
+  '#api/webapps': './server_src/webapps/api',
+  '#api': './server_src/api',
+  '#components': './server_src/webapps/components',
+  ...config?.rollup?.client?.alias,
+});
+
+export function getAliasClientPlugin() {
+  return alias({ entries: clientAlias });
+}
+
+const serverAlias = resolveAlias(config.projectRoot, {
+  '#api/webapps': './server_src/webapps/api',
+  '#api/restapps': './server_src/restapps/api',
+  '#api': './server_src/api',
+  '#components': './server_src/webapps/components',
+  ...config?.rollup?.server?.alias,
+});
+
+export function getAliasServerPlugin() {
+  return alias({ entries: serverAlias });
+}

package/rollup/api/getBabelPlugin.js

@@ -0,0 +1,34 @@
+import { babel } from '@rollup/plugin-babel';
+
+const commonOptions = {
+  babelrc: false,
+  extensions: ['.js', '.mjs', '.html', '.svelte'],
+  babelHelpers: 'bundled',
+  plugins: ['babel-plugin-transform-async-to-promises'],
+};
+
+export function getBabelClientPlugin() {
+  return babel({
+    ...commonOptions,
+    presets: [
+      ['@babel/preset-env', {
+        shippedProposals: true,
+      }],
+    ],
+  });
+}
+
+export function getBabelServerPlugin() {
+  return babel({
+    ...commonOptions,
+    presets: [
+      ['@babel/preset-env', {
+        exclude: ['@babel/plugin-transform-arrow-functions'],
+        forceAllTransforms: true,
+        ignoreBrowserslistConfig: true,
+        shippedProposals: true,
+        loose: true,
+      }],
+    ],
+  });
+}

package/rollup/api/getCommonjsPlugin.js

@@ -0,0 +1,5 @@
+import commonjs from '@rollup/plugin-commonjs';
+
+export default function getCommonjsPlugin() {
+  return commonjs({ requireReturnsDefault: 'preferred' });
+}

package/rollup/api/getFilesizePlugin.js

@@ -0,0 +1,5 @@
+import filesize from 'rollup-plugin-filesize';
+
+export default function getFilesizePlugin({ showSize }) {
+  return showSize ? filesize() : false;
+}

package/rollup/api/getInsertPlugin.js

@@ -0,0 +1,14 @@
+import { transform } from 'rollup-plugin-insert';
+import { existsSync } from 'fs';
+import slash from 'slash';
+import { relative, dirname } from 'path';
+
+export default function getInsertPlugin({ input, imports }) {
+  return transform((ms, code) => {
+    const existingImports = imports
+      .filter((importee) => importee && existsSync(importee))
+      .map((importee) => slash(relative(dirname(input), importee)))
+      .map((importee) => `import './${importee}';`);
+    return `${existingImports.join('\n')}\n${code}`;
+  }, { include: input });
+}

package/rollup/api/getNodeResolvePlugin.js

@@ -0,0 +1,11 @@
+import nodeResolve from '@rollup/plugin-node-resolve';
+
+export default function getNodeResolvePlugin() {
+  return nodeResolve({
+    mainFields: ['module', 'browser', 'main'],
+    extensions: ['.js', '.mjs', '.json', '.svelte'],
+    dedupe(importee) {
+      return importee === 'svelte' || importee.startsWith('svelte/');
+    },
+  });
+}

package/rollup/api/getPostcssPlugin.js

@@ -0,0 +1,24 @@
+import postcss from 'rollup-plugin-postcss';
+
+import autoprefixer from 'autoprefixer';
+import pxtorem from 'postcss-pxtorem';
+import discardDuplicates from 'postcss-discard-duplicates';
+
+import config from '@soleil-se/build-config';
+import preprocessOptions from './common/preprocessOptions.js';
+
+const plugins = [autoprefixer(config?.css?.plugins?.autoprefixer), discardDuplicates()];
+
+if (config?.css?.plugins?.pxtorem) {
+  plugins.push(pxtorem(config?.css.plugins.pxtorem));
+}
+
+export default function getPostcssPlugin({ cssOutput, debug }) {
+  return postcss({
+    plugins,
+    extract: !!cssOutput && !debug,
+    minimize: !debug ? { level: 2 } : false,
+    sourceMap: debug ? 'inline' : false,
+    use: preprocessOptions,
+  });
+}

package/rollup/api/getReplacePlugin.js

@@ -0,0 +1,19 @@
+import replace from '@rollup/plugin-replace';
+import config from '@soleil-se/build-config';
+
+export function getReplaceClientPlugin() {
+  return replace({
+    'process.server': false,
+    'process.browser': true,
+    'process.env.NODE_ENV': JSON.stringify(config.env.production ? 'production' : 'development'),
+    preventAssignment: true,
+  });
+}
+
+export function getReplaceServerPlugin() {
+  return replace({
+    'process.server': true,
+    'process.browser': false,
+    preventAssignment: true,
+  });
+}

package/rollup/api/getSveltePlugin.js

@@ -0,0 +1,44 @@
+import { dirname } from 'path';
+import { findUpSync } from 'find-up';
+import fse from 'fs-extra';
+import { kebabCase } from 'lodash-es';
+
+import preprocessOptions from './common/preprocessOptions.js';
+
+let svelte;
+let sveltePreprocess;
+
+const validClassRegex = /[^a-z0-9\-_]|^[^a-z]+/gi;
+
+const hasSvelte = (input) => {
+  const packageFile = findUpSync('package.json', { cwd: dirname(input) });
+  const { dependencies = {} } = fse.readJSONSync(packageFile);
+  return Object.keys(dependencies).includes('svelte');
+};
+
+/* Custom CSS hash requires version 3.34.0 or later */
+const cssHash = ({ hash, css, name }) => {
+  const validClass = name.replace(validClassRegex, '');
+  return `${kebabCase(validClass)}-${hash(css)}`;
+};
+
+export default async function getSveltePlugin({
+  input, debug = false, emitCss = true, ssr, hydratable = true,
+}) {
+  if (hasSvelte(input)) {
+    svelte = svelte || await import('rollup-plugin-svelte').then((pkg) => pkg.default);
+    sveltePreprocess = sveltePreprocess || await import('svelte-preprocess').then((pkg) => pkg.default);
+
+    return svelte({
+      preprocess: sveltePreprocess(preprocessOptions),
+      emitCss,
+      compilerOptions: {
+        generate: ssr ? 'ssr' : 'dom',
+        hydratable,
+        dev: debug,
+        cssHash,
+      },
+    });
+  }
+  return false;
+}

package/rollup/api/getTerserPlugin.js

@@ -0,0 +1,9 @@
+import { terser } from 'rollup-plugin-terser';
+
+export default function getTerserPlugin({ debug }) {
+  return debug ? false : terser({
+    format: {
+      comments: false,
+    },
+  });
+}

package/rollup/client.js

@@ -0,0 +1,85 @@
+import { rollup } from 'rollup';
+import json from '@rollup/plugin-json';
+
+import fse from 'fs-extra';
+
+import generateBanner from './utils/generateBanner.js';
+import moveCss from './utils/moveCss.js';
+import onwarn from './utils/onwarn.js';
+import getSitevisionClientPackages from './utils/getSitevisionClientPackages.js';
+
+import { getReplaceClientPlugin } from './api/getReplacePlugin.js';
+import { getAliasClientPlugin } from './api/getAliasPlugin.js';
+import { getBabelClientPlugin } from './api/getBabelPlugin.js';
+import getCommonjsPlugin from './api/getCommonjsPlugin.js';
+import getNodeResolvePlugin from './api/getNodeResolvePlugin.js';
+import getSveltePlugin from './api/getSveltePlugin.js';
+import getPostcssPlugin from './api/getPostcssPlugin.js';
+import getFilesizePlugin from './api/getFilesizePlugin.js';
+import getTerserPlugin from './api/getTerserPlugin.js';
+import sitevision from './plugins/sitevision-client.js';
+import getInsertPlugin from './api/getInsertPlugin.js';
+
+export default function rollupClient({
+  debug,
+  globals = {},
+  input,
+  output,
+  cssOutput,
+  showSize = true,
+  bundled,
+  hydratable,
+  cache = true,
+} = {}) {
+  if (!input) return false;
+
+  let bundleCache;
+  let plugins;
+
+  const external = Object.keys(globals);
+  if (bundled) external.push(...getSitevisionClientPackages());
+
+  return async () => {
+    if (!fse.existsSync(input)) return Promise.resolve();
+
+    plugins = plugins || [
+      bundled ? sitevision() : false,
+      getReplaceClientPlugin(),
+      getAliasClientPlugin(),
+      getNodeResolvePlugin(),
+      getCommonjsPlugin(),
+      getInsertPlugin({ input, imports: [cssOutput] }),
+      await getSveltePlugin({ input, debug, emitCss: !!cssOutput, hydratable }),
+      getPostcssPlugin({ cssOutput, debug }),
+      getBabelClientPlugin(),
+      json(),
+      getFilesizePlugin({ showSize }),
+      getTerserPlugin({ debug }),
+    ];
+
+    try {
+      const bundle = await rollup({
+        external,
+        input,
+        plugins,
+        onwarn,
+        cache: bundleCache,
+      });
+
+      bundleCache = cache && bundle.cache;
+      await bundle.write({
+        file: output,
+        banner: debug && generateBanner(),
+        globals,
+        format: bundled ? 'amd' : 'iife',
+        sourcemap: debug ? 'inline' : false,
+        interop: 'auto',
+      });
+
+      return moveCss(cssOutput, output);
+    } catch (e) {
+      bundleCache = undefined;
+      throw e;
+    }
+  };
+}

package/rollup/index.js

@@ -0,0 +1,2 @@
+export { default as client } from './client.js';
+export { default as server } from './server.js';

package/rollup/plugins/sitevision-client.js

@@ -0,0 +1,45 @@
+export default function sitevision() {
+  const ignored = [];
+
+  function isSitevisionScope(id) {
+    return id.startsWith('@sitevision/api');
+  }
+
+  function shouldResolve(importee) {
+    if (isSitevisionScope(importee)) {
+      return false;
+    }
+    return true;
+  }
+
+  function shouldLoad(id) {
+    return !ignored.includes(id);
+  }
+
+  return {
+    name: 'sitevision-imports',
+    resolveId(importee) {
+      if (shouldResolve(importee)) {
+        // Should be handled as usual.
+        return null;
+      }
+      // Most likely a SiteVision dependency.
+      // Do not ask other plugins or check the file system to find it.
+      if (!ignored.includes(importee)) {
+        ignored.push(importee);
+      }
+      return importee;
+    },
+    load(id) {
+      if (shouldLoad(id)) {
+        return null;
+      }
+      // The virtual source code for the provided Sitevision dependency.
+      const pkg = id.split('/').pop();
+      return {
+        code: `export { default } from '${pkg}';`,
+        syntheticNamedExports: true,
+      };
+    },
+  };
+}

package/rollup/plugins/sitevision-server.js

@@ -0,0 +1,81 @@
+import { camelCase } from 'lodash-es';
+import { isAbsolute } from 'path';
+
+const sitevisionPackages = [
+  'underscore',
+  'router',
+  'i18n',
+  'appData',
+  'globalAppData',
+  'appResource',
+  'appInfo',
+  'storage',
+  'oauth2',
+  'privileged',
+  'app',
+  'events',
+  'hooks',
+  'cache',
+];
+
+export default function sitevision() {
+  const ignored = [];
+
+  function startsWithUpperCase(id) {
+    return /^[A-Z]/.test(id);
+  }
+
+  function isSitevisionPath(id) {
+    if (isAbsolute(id) && !id.startsWith('/')) {
+      return false;
+    }
+    return startsWithUpperCase(id);
+  }
+
+  function isExcluded(id) {
+    return sitevisionPackages.includes(id);
+  }
+
+  function isSitevisionScope(id) {
+    return id.startsWith('@sitevision/api');
+  }
+
+  function shouldResolve(importee) {
+    if (isSitevisionScope(importee) || isExcluded(importee) || isSitevisionPath(importee)) {
+      return false;
+    }
+    return true;
+  }
+
+  function shouldLoad(id) {
+    return !ignored.includes(id);
+  }
+
+  return {
+    name: 'sitevision-imports',
+    resolveId(importee) {
+      if (shouldResolve(importee)) {
+        // Should be handled as usual.
+        return null;
+      }
+      // Most likely a SiteVision dependency.
+      // Do not ask other plugins or check the file system to find it.
+      if (!ignored.includes(importee)) {
+        ignored.push(importee);
+      }
+      return importee;
+    },
+    load(id) {
+      if (shouldLoad(id)) {
+        return null;
+      }
+      // The virtual source code for the provided SiteVision dependency.
+      const pkg = id.split('/').pop();
+      const name = camelCase(pkg);
+      return {
+        code: `var ${name} = require('${pkg}'); export default ${name}`,
+        syntheticNamedExports: true,
+      };
+    },
+  };
+}

package/rollup/server.js

@@ -0,0 +1,76 @@
+import { rollup } from 'rollup';
+import json from '@rollup/plugin-json';
+import { string } from 'rollup-plugin-string';
+import cleanup from 'rollup-plugin-cleanup';
+
+import fse from 'fs-extra';
+
+import generateBanner from './utils/generateBanner.js';
+import moveCss from './utils/moveCss.js';
+import onwarn from './utils/onwarn.js';
+import sitevision from './plugins/sitevision-server.js';
+
+import { getReplaceServerPlugin } from './api/getReplacePlugin.js';
+import { getAliasServerPlugin } from './api/getAliasPlugin.js';
+import { getBabelServerPlugin } from './api/getBabelPlugin.js';
+import getCommonjsPlugin from './api/getCommonjsPlugin.js';
+import getInsertPlugin from './api/getInsertPlugin.js';
+import getNodeResolvePlugin from './api/getNodeResolvePlugin.js';
+import getSveltePlugin from './api/getSveltePlugin.js';
+import getPostcssPlugin from './api/getPostcssPlugin.js';
+import getTerserPlugin from './api/getTerserPlugin.js';
+
+export default function rollupServer({
+  debug,
+  input,
+  output,
+  cssOutput,
+  bundled,
+  cache = true,
+} = {}) {
+  if (!input) return false;
+
+  let bundleCache;
+  let plugins;
+
+  return async () => {
+    if (!fse.existsSync(input)) return Promise.resolve();
+
+    plugins = plugins || [
+      getReplaceServerPlugin(),
+      getAliasServerPlugin(),
+      sitevision(),
+      json(),
+      string({ include: '**/*.html' }),
+      getNodeResolvePlugin(),
+      getCommonjsPlugin(),
+      getInsertPlugin({ input, imports: [cssOutput] }),
+      await getSveltePlugin({ input, emitCss: !!cssOutput, ssr: true }),
+      getPostcssPlugin({ cssOutput, debug }),
+      getBabelServerPlugin(),
+      bundled ? getTerserPlugin({ debug }) : cleanup({ maxEmptyLines: 1 }),
+    ];
+
+    try {
+      const bundle = await rollup({
+        input,
+        plugins,
+        onwarn,
+        cache: bundleCache,
+      });
+
+      bundleCache = cache && bundle.cache;
+      await bundle.write({
+        file: output,
+        banner: debug && generateBanner(),
+        intro: 'var Promise = Promise || { resolve: () => {} };',
+        format: 'iife',
+      });
+
+      return moveCss(cssOutput, output);
+    } catch (e) {
+      bundleCache = undefined;
+      throw e;
+    }
+  };
+}

package/rollup/utils/generateBanner.js

@@ -0,0 +1,9 @@
+import { template } from 'lodash-es';
+import fse from 'fs-extra';
+import config from '@soleil-se/build-config';
+
+const { name, version } = fse.readJSONSync(new URL('../../package.json', import.meta.url));
+
+export default function generateBanner() {
+  return template(config.banner)({ date: new Date(), build: `${name} - ${version}` });
+}

package/rollup/utils/getSitevisionClientPackages.js

@@ -0,0 +1,7 @@
+import { existsSync, readdirSync } from 'fs';
+
+export default function getSitevisionClientPackages() {
+  const path = `${process.cwd()}/node_modules/@sitevision/api`;
+  if (!existsSync(path)) throw new Error('Bundled apps requires @sitevision/api to be installed.');
+  return [...readdirSync(`${path}/client`), ...readdirSync(`${path}/common`)];
+}

package/rollup/utils/moveCss.js

@@ -0,0 +1,10 @@
+import fse from 'fs-extra';
+
+export default function moveCss(css, output) {
+  if (css && fse.existsSync(output.replace('.js', '.css'))) {
+    return fse.move(output.replace('.js', '.css'), css, {
+      overwrite: true,
+    });
+  }
+  return Promise.resolve();
+}

package/rollup/utils/onwarn.js

@@ -0,0 +1,15 @@
+import { logWarning } from '@soleil-se/build-utils/log';
+
+export default function onwarn(warning) {
+  if (warning.code === 'CIRCULAR_DEPENDENCY') return;
+
+  if (warning.code === 'PLUGIN_WARNING') {
+    if (warning.pluginCode && warning.pluginCode === 'a11y-no-onchange') return;
+  }
+
+  if (warning.code === 'UNRESOLVED_IMPORT') {
+    const message = warning.message.replace(' – treating it as an external dependency', '. Have you installed it?');
+    throw new Error(message);
+  }
+  logWarning(warning.message);
+}

package/utils/clean.js

@@ -0,0 +1,5 @@
+import fse from 'fs-extra';
+
+export default function clean({ dir }) {
+  return () => fse.emptyDir(dir);
+}

package/utils/configFiles.js

@@ -0,0 +1,11 @@
+import fse from 'fs-extra';
+
+async function createIndexFile(path) {
+  if (!fse.existsSync(path)) {
+    await fse.writeFile(path, '<div id="app_root"></div>');
+  }
+}
+
+export default function files({ dest }) {
+  return () => createIndexFile(`${dest}/index.html`);
+}

package/utils/copy.js

@@ -0,0 +1,12 @@
+import fse from 'fs-extra';
+import { basename, join } from 'path';
+
+export default function copy({ src, dest }) {
+  const files = Array.isArray(src) ? src : [src];
+
+  return () => Promise.all(
+    files.map((file) => (
+      fse.existsSync(file) ? fse.copy(file, join(dest, basename(file))) : Promise.resolve()
+    )),
+  );
+}

package/utils/eslint.js

@@ -0,0 +1,37 @@
+import chalk from 'chalk';
+import { getTimestamp, logWarning } from '@soleil-se/build-utils/log';
+
+const logNotInstalledWarning = () => {
+  logWarning(`ESLint is not installed, run ${chalk.white('yarn add eslint --dev')} or start with ${chalk.white('--no-eslint')} flag.`);
+};
+
+let ESLint;
+
+export default function createESLint({ src }) {
+  return async () => {
+    try {
+      // eslint-disable-next-line import/no-extraneous-dependencies,node/no-extraneous-import
+      ESLint = ESLint || await import('eslint').then((pkg) => pkg.ESLint);
+    } catch (e) {
+      logNotInstalledWarning();
+    }
+    if (ESLint) {
+      const eslint = new ESLint();
+      const formatter = await eslint.loadFormatter();
+      const results = await eslint.lintFiles(src);
+      const errors = ESLint.getErrorResults(results);
+      const output = formatter.format(results);
+
+      if (errors.length) {
+        const error = new Error(`\n${output}`);
+        error.showStack = false;
+        throw error;
+      }
+      if (output) {
+        console.log(`${getTimestamp()} Warning:\n${output}`);
+      }
+    } else {
+      logNotInstalledWarning();
+    }
+  };
+}

package/utils/files.js

@@ -0,0 +1,28 @@
+import fse from 'fs-extra';
+
+const indexContent = `(function() {
+  'use strict';
+  var router = require('router');
+  router.get('/', function() {});
+}());`;
+
+async function createMain(dest) {
+  const src = `${dest}/src/main.js`;
+  if (!fse.existsSync(src)) {
+    await fse.writeFile(src, '');
+  }
+}
+
+async function createIndex(dest) {
+  const src = `${dest}/src/index.js`;
+  if (!fse.existsSync(src)) {
+    await fse.writeFile(src, indexContent);
+  }
+}
+
+export default function files({ type, dest }) {
+  if (type.toLowerCase() === 'restapp') return undefined;
+  return () => Promise.all(
+    [createMain(dest), createIndex(dest)],
+  );
+}

package/utils/index.js

@@ -0,0 +1,5 @@
+export { default as clean } from './clean.js';
+export { default as copy } from './copy.js';
+export { default as eslint } from './eslint.js';
+export { default as files } from './files.js';
+export { default as zip } from './zip.js';

package/utils/zip.js

@@ -0,0 +1,18 @@
+import archiver from 'archiver';
+import fse from 'fs-extra';
+
+export default function zip({ src, dest }) {
+  return () => {
+    const archive = archiver('zip', { zlib: { level: 9 } });
+    const stream = fse.createWriteStream(dest);
+
+    return new Promise((resolve, reject) => {
+      archive
+        .directory(src, false)
+        .on('error', (err) => reject(err))
+        .pipe(stream);
+      stream.on('close', () => resolve());
+      archive.finalize();
+    });
+  };
+}