oc-template-elm-compiler 0.0.11 → 0.1.0-beta.1

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './lib/compile';
+export * from 'oc-template-elm';

package/dist/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./lib/compile"), exports);
+__exportStar(require("oc-template-elm"), exports);

package/dist/lib/compile.d.ts

@@ -0,0 +1,3 @@
+import { createCompile } from 'oc-generic-template-compiler';
+export type CompilerOptions = ReturnType<typeof createCompile>;
+export declare const compile: CompilerOptions;

package/dist/lib/compile.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compile = void 0;
+const oc_generic_template_compiler_1 = require("oc-generic-template-compiler");
+const oc_statics_compiler_1 = __importDefault(require("oc-statics-compiler"));
+const oc_template_elm_1 = require("oc-template-elm");
+const oc_vite_compiler_1 = require("oc-vite-compiler");
+const vite_plugin_elm_1 = __importDefault(require("vite-plugin-elm"));
+const elmOCProviderTemplate_1 = __importDefault(require("./elmOCProviderTemplate"));
+const htmlTemplate_1 = __importDefault(require("./htmlTemplate"));
+exports.compile = (0, oc_generic_template_compiler_1.createCompile)({
+    compileView: (options, cb) => (0, oc_vite_compiler_1.viteView)({
+        ...options,
+        plugins: [(0, vite_plugin_elm_1.default)()],
+        viewWrapper: ({ viewPath }) => (0, elmOCProviderTemplate_1.default)({ viewPath, jsPath: undefined }),
+        htmlTemplate: (props) => (0, htmlTemplate_1.default)({ ...props, bundleName: 'dontknow' }),
+        externals: (0, oc_template_elm_1.getInfo)().externals
+    }, cb),
+    compileServer: oc_vite_compiler_1.viteServer,
+    compileStatics: oc_statics_compiler_1.default,
+    getInfo: oc_template_elm_1.getInfo
+});
+// OPTIONS
+// =======
+// componentPath
+// componentPackage,
+// logger,
+// minify
+// ocPackage
+// publishPath
+// verbose,
+// watch,
+// production

package/dist/lib/compileServer.d.ts

@@ -0,0 +1,7 @@
+declare const async: any;
+declare const fs: any;
+declare const hashBuilder: any;
+declare const MemoryFS: any;
+declare const path: any;
+declare const compiler: any, webpackConfigurator: any;
+declare const higherOrderServerTemplate: any;

package/dist/lib/compileServer.js

@@ -0,0 +1,73 @@
+'use strict';
+const async = require('async');
+const fs = require('fs-extra');
+const hashBuilder = require('oc-hash-builder');
+const MemoryFS = require('memory-fs');
+const path = require('path');
+const { compiler, configurator: { server: webpackConfigurator } } = require('./to-abstract-base-template-utils/oc-webpack');
+const higherOrderServerTemplate = require('./higherOrderServerTemplate');
+module.exports = (options, callback) => {
+    const componentPath = options.componentPath;
+    const serverFileName = options.componentPackage.oc.files.data;
+    let serverPath = path.join(options.componentPath, serverFileName);
+    if (process.platform === 'win32') {
+        serverPath = serverPath.split('\\').join('\\\\');
+    }
+    const publishFileName = options.publishFileName || 'server.js';
+    const publishPath = options.publishPath;
+    const stats = options.verbose ? 'verbose' : 'errors-only';
+    const dependencies = options.componentPackage.dependencies || {};
+    const componentName = options.componentPackage.name;
+    const componentVersion = options.componentPackage.version;
+    const production = options.production;
+    const higherOrderServerContent = higherOrderServerTemplate({
+        serverPath,
+        componentName,
+        componentVersion,
+        bundleHashKey: options.compiledViewInfo.bundle.hashKey
+    });
+    const tempFolder = path.join(serverPath, '../_package/temp');
+    const higherOrderServerPath = path.join(tempFolder, '__oc_higherOrderServer.ts');
+    const config = webpackConfigurator({
+        componentPath,
+        serverPath: higherOrderServerPath,
+        publishFileName,
+        dependencies,
+        stats,
+        production
+    });
+    async.waterfall([
+        (next) => fs.outputFile(higherOrderServerPath, higherOrderServerContent, next),
+        (next) => {
+            return compiler(config, next);
+        },
+        (data, next) => {
+            const basePath = path.join(tempFolder, 'build');
+            const memory = new MemoryFS(data);
+            const getCompiled = (fileName) => memory.readFileSync(`${basePath}/${fileName}`, 'UTF8');
+            return fs.ensureDir(publishPath, (err) => {
+                if (err)
+                    return next(err);
+                const result = { 'server.js': getCompiled(config.output.filename) };
+                if (!production) {
+                    try {
+                        result['server.js.map'] = getCompiled(`${config.output.filename}.map`);
+                    }
+                    catch (e) {
+                        // skip sourcemap if it doesn't exist
+                    }
+                }
+                next(null, result);
+            });
+        },
+        (compiledFiles, next) => {
+            return async.eachOf(compiledFiles, (fileContent, fileName, next) => fs.writeFile(path.join(publishPath, fileName), fileContent, next), (err) => next(err, err
+                ? null
+                : {
+                    type: 'node.js',
+                    hashKey: hashBuilder.fromString(compiledFiles[publishFileName]),
+                    src: publishFileName
+                }));
+        }
+    ], (err, data) => fs.remove(tempFolder, (_err2) => callback(err, data)));
+};

package/dist/lib/compileView.d.ts

@@ -0,0 +1,12 @@
+declare const async: any;
+declare const fs: any;
+declare const hashBuilder: any;
+declare const MemoryFS: any;
+declare const ocViewWrapper: any;
+declare const path: any;
+declare const strings: any;
+declare const elmComponentWrapper: (hash: any, content: any, nameSpace: any) => string;
+declare const compiler: any, webpackConfigurator: any;
+declare const fontFamilyUnicodeParser: any;
+declare const elmOCProviderTemplate: any;
+declare const viewTemplate: any;

package/dist/lib/compileView.js

@@ -0,0 +1,102 @@
+'use strict';
+const async = require('async');
+const fs = require('fs-extra');
+const hashBuilder = require('oc-hash-builder');
+const MemoryFS = require('memory-fs');
+const ocViewWrapper = require('oc-view-wrapper');
+const path = require('path');
+const strings = require('oc-templates-messages');
+const elmComponentWrapper = (hash, content, nameSpace) => {
+    nameSpace = nameSpace || 'oc';
+    return `var ${nameSpace}=${nameSpace}||{};${nameSpace}.elmComponents=${nameSpace}.elmComponents||{};${nameSpace}.elmComponents['${hash}']=${nameSpace}.elmComponents['${hash}']||(function(){var ${content}
+	; return module.default}())`;
+};
+const { compiler, configurator: { client: webpackConfigurator } } = require('./to-abstract-base-template-utils/oc-webpack');
+const fontFamilyUnicodeParser = require('./to-abstract-base-template-utils/font-family-unicode-parser');
+const elmOCProviderTemplate = require('./elmOCProviderTemplate');
+const viewTemplate = require('./viewTemplate');
+module.exports = (options, callback) => {
+    const viewFileName = options.componentPackage.oc.files.template.src;
+    const jsFileName = options.componentPackage.oc.files.template.js;
+    const componentPath = options.componentPath;
+    let viewPath = path.join(options.componentPath, viewFileName);
+    let jsPath = jsFileName && path.join(options.componentPath, viewFileName);
+    if (process.platform === 'win32') {
+        viewPath = viewPath.split('\\').join('\\\\');
+        jsPath = jsPath && jsPath.split('\\').join('\\\\');
+    }
+    const publishPath = options.publishPath;
+    const tempPath = path.join(publishPath, 'temp');
+    const publishFileName = options.publishFileName || 'template.js';
+    const componentPackage = options.componentPackage;
+    const production = options.production;
+    const elmOCProviderContent = elmOCProviderTemplate({ viewPath, jsPath });
+    const elmOCProviderName = 'elmOCProvider.js';
+    const elmOCProviderPath = path.join(tempPath, elmOCProviderName);
+    const compile = (options, cb) => {
+        const config = webpackConfigurator({
+            componentPath,
+            viewPath: options.viewPath,
+            publishFileName,
+            production,
+            buildIncludes: componentPackage.oc.files.template.buildIncludes || []
+        });
+        compiler(config, (err, data) => {
+            if (err) {
+                return cb(err);
+            }
+            const memoryFs = new MemoryFS(data);
+            const bundle = memoryFs.readFileSync(`/build/${config.output.filename}`, 'UTF8');
+            const bundleHash = hashBuilder.fromString(bundle);
+            const bundleName = 'elm-component';
+            const bundlePath = path.join(publishPath, `${bundleName}.js`);
+            const wrappedBundle = elmComponentWrapper(bundleHash, bundle);
+            fs.outputFileSync(bundlePath, wrappedBundle);
+            let css = null;
+            if (data.build['main.css']) {
+                // This is an awesome hack by KimTaro that will blow your mind.
+                // Remove it once this get merged: https://github.com/webpack-contrib/css-loader/pull/523
+                css = fontFamilyUnicodeParser(memoryFs.readFileSync(`/build/main.css`, 'UTF8'));
+                const cssPath = path.join(publishPath, `styles.css`);
+                // We convert single quotes to double quotes in order to
+                // support the viewTemplate's string interpolation
+                fs.outputFileSync(cssPath, css.replace(/'/g, '"'));
+            }
+            const elmRoot = `oc-elmRoot-${componentPackage.name}`;
+            const templateString = viewTemplate({
+                elmRoot,
+                css,
+                bundleHash,
+                bundleName
+            });
+            const templateStringCompressed = production
+                ? templateString.replace(/\s+/g, ' ')
+                : templateString;
+            const hash = hashBuilder.fromString(templateStringCompressed);
+            const view = ocViewWrapper(hash, templateStringCompressed);
+            return cb(null, {
+                template: { view, hash },
+                bundle: { hash: bundleHash }
+            });
+        });
+    };
+    async.waterfall([
+        (next) => fs.outputFile(elmOCProviderPath, elmOCProviderContent, next),
+        (next) => compile({ viewPath: elmOCProviderPath }, next),
+        (compiled, next) => fs.remove(elmOCProviderPath, (err) => next(err, compiled)),
+        (compiled, next) => fs.ensureDir(publishPath, (err) => next(err, compiled)),
+        (compiled, next) => fs.writeFile(path.join(publishPath, publishFileName), compiled.template.view, (err) => next(err, compiled))
+    ], (err, compiled) => {
+        if (err) {
+            return callback(strings.errors.compilationFailed(viewFileName, err));
+        }
+        callback(null, {
+            template: {
+                type: options.componentPackage.oc.files.template.type,
+                hashKey: compiled.template.hash,
+                src: publishFileName
+            },
+            bundle: { hashKey: compiled.bundle.hash }
+        });
+    });
+};

package/dist/lib/elmOCProviderTemplate.d.ts

@@ -0,0 +1,4 @@
+export default function elmOCProviderTemplate({ jsPath, viewPath }: {
+    jsPath?: string;
+    viewPath: string;
+}): string;

package/{lib → dist/lib}/elmOCProviderTemplate.js

@@ -1,8 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 const extractName = (path) => path.match(/(\w+)\.elm$/)[1];
 const removeJsExtension = (path) => path.replace(/\.(t|j)s?$/, '');
-
-const elmOCProviderTemplate = ({ jsPath, viewPath }) => `
-  import Component from '${viewPath}';
+function elmOCProviderTemplate({ jsPath, viewPath }) {
+    return `
+  import { Elm } from '${viewPath}';
   ${jsPath ? `import jsApp from '${removeJsExtension(jsPath)}'` : ''}
 
   function getData(providerProps, parameters, cb) {
@@ -20,8 +22,13 @@ const elmOCProviderTemplate = ({ jsPath, viewPath }) => `
     });
   }
 
-  function init({ node, flags: { _baseUrl, _componentName, _componentVersion, _staticPath, ...flags } }) {
+  function renderer(model, node) {
+    const { _baseUrl, _componentName, _componentVersion, _staticPath, ...props } = model;
     const app = Component.Elm["${extractName(viewPath)}"].init({ node, flags });
+    const app = Elm["${extractName(viewPath)}"].init({
+      node,
+      flags: props
+    })
 
     if (app.ports && app.ports.getData) {
       app.ports.getData.subscribe(parameters => {
@@ -43,5 +50,5 @@ const elmOCProviderTemplate = ({ jsPath, viewPath }) => `
 
   export default init;
 `;
-
-module.exports = elmOCProviderTemplate;
+}
+exports.default = elmOCProviderTemplate;

package/dist/lib/higherOrderServerTemplate.d.ts

@@ -0,0 +1,7 @@
+declare const removeTsExtension: (path: any) => any;
+declare const higherOrderServerTemplate: ({ serverPath, bundleHashKey, componentName, componentVersion }: {
+    serverPath: any;
+    bundleHashKey: any;
+    componentName: any;
+    componentVersion: any;
+}) => string;

package/{lib → dist/lib}/higherOrderServerTemplate.js

@@ -1,11 +1,6 @@
+"use strict";
 const removeTsExtension = (path) => path.replace(/\.tsx?$/, '');
-
-const higherOrderServerTemplate = ({
-  serverPath,
-  bundleHashKey,
-  componentName,
-  componentVersion
-}) => `
+const higherOrderServerTemplate = ({ serverPath, bundleHashKey, componentName, componentVersion }) => `
 import { data as dataProvider } from '${removeTsExtension(serverPath)}';
 
 export const data = (context : any, callback : (error: any, data?: any) => void) => {
@@ -31,5 +26,4 @@ export const data = (context : any, callback : (error: any, data?: any) => void)
   });
 }
 `;
-
 module.exports = higherOrderServerTemplate;

package/dist/lib/htmlTemplate.d.ts

@@ -0,0 +1,6 @@
+export default function viewTemplate({ templateId, css, hash, bundleName }: {
+    templateId: string;
+    css: string;
+    hash: string;
+    bundleName: string;
+}): string;

package/dist/lib/htmlTemplate.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const cssesc_1 = __importDefault(require("cssesc"));
+function viewTemplate({ templateId, css, hash, bundleName }) {
+    return `function elmViewTemplate(model) {
+  var modelHTML =  model.__html ? model.__html : '';
+  var staticPath = model.component.flags._staticPath;
+  var flags = JSON.stringify(model.component.flags);
+  window.oc = window.oc || {};
+  window.oc.__elmTemplate = window.oc.__elmTemplate || { count: 0 };
+  var count = window.oc.__elmTemplate.count;
+  var templateId = "${templateId}-" + count;
+  window.oc.__elmTemplate.count++;
+  return '<div id="' + templateId + '" class="${templateId}">' + modelHTML + '</div>' +
+    '${css ? '<style>' + (0, cssesc_1.default)(css) + '</style>' : ''}' +
+    '<script>' +
+    'window.oc = window.oc || {};' +
+    'oc.cmd = oc.cmd || [];' +
+    'oc.cmd.push(function(oc){' +
+    '${css ? "oc.events.fire(\\'oc:cssDidMount\\', \\'" + css + "\\');" : ''}' +
+      'oc.require(' +
+        '["oc", "elmComponents", "${hash}"],' + 
+        '"' + staticPath + '${bundleName}.js",' +
+        'function(ElmComponent) {' +
+          'var targetNode = document.getElementById("' + templateId + '");' +
+          'targetNode.setAttribute("id","");' +
+          'ElmComponent({ node: targetNode, flags:' + flags + '});' +
+        '}' +
+      ');' +
+    '});' +
+  '</script>'
+}`;
+}
+exports.default = viewTemplate;

package/dist/lib/to-abstract-base-template-utils/font-family-unicode-parser.d.ts

@@ -0,0 +1,5 @@
+declare const RE_FONT_FAMILY: RegExp;
+declare const RE_FONT_NAMES: RegExp;
+declare const RE_DOUBLE_COUTE: RegExp;
+declare const RE_SPACE: RegExp;
+declare const RE_UNICODE: RegExp;

package/dist/lib/to-abstract-base-template-utils/font-family-unicode-parser.js

@@ -0,0 +1,23 @@
+"use strict";
+const RE_FONT_FAMILY = /font-family\s*:\s*([^;\n]+)[;\n]/g;
+const RE_FONT_NAMES = /(?:(?:'|(?:\\"))?([(?:\\\\)\w\d _-]+)(?:'|(?:\\"))?(,\s*)?)/g;
+const RE_DOUBLE_COUTE = /"/g;
+const RE_SPACE = /[ ]+/g;
+const RE_UNICODE = /\\([\d\w]{4})/g;
+module.exports = function (source) {
+    source = source.replace(RE_FONT_FAMILY, (str, fontNames) => {
+        const strFontNames = fontNames
+            .replace(RE_DOUBLE_COUTE, "'")
+            .replace(RE_FONT_NAMES, (match, fontName, sep) => {
+            if (match.includes("'")) {
+                const replacement = fontName
+                    .replace(RE_SPACE, ' ')
+                    .replace(RE_UNICODE, (m, unicode) => String.fromCharCode(parseInt(unicode, 16)));
+                return `'${replacement}'${sep || ''}`;
+            }
+            return match;
+        });
+        return `font-family: ${strFontNames};`;
+    });
+    return source;
+};

package/dist/lib/verifyConfig.d.ts

@@ -0,0 +1,8 @@
+declare const chalk: any;
+declare const fs: any;
+declare const resolve: any;
+declare const path: any;
+declare const os: any;
+declare const immer: any;
+declare function writeJson(fileName: any, object: any): void;
+declare function verifyTypeScriptSetup(componentPath: any): void;

package/dist/lib/verifyConfig.js

@@ -0,0 +1,146 @@
+"use strict";
+const chalk = require('chalk');
+const fs = require('fs');
+const resolve = require('resolve');
+const path = require('path');
+const os = require('os');
+const immer = require('immer').produce;
+function writeJson(fileName, object) {
+    fs.writeFileSync(fileName, JSON.stringify(object, null, 2).replace(/\n/g, os.EOL) + os.EOL);
+}
+function verifyTypeScriptSetup(componentPath) {
+    const paths = {
+        appTsConfig: path.resolve(componentPath, 'tsconfig.json'),
+        yarnLockFile: path.resolve(componentPath, 'yarn.lock'),
+        appNodeModules: path.resolve(componentPath, 'node_modules')
+    };
+    let firstTimeSetup = false;
+    if (!fs.existsSync(paths.appTsConfig)) {
+        writeJson(paths.appTsConfig, {});
+        firstTimeSetup = true;
+    }
+    const isYarn = fs.existsSync(paths.yarnLockFile);
+    // Ensure typescript is installed
+    let ts;
+    try {
+        ts = require(resolve.sync('typescript', {
+            basedir: paths.appNodeModules
+        }));
+    }
+    catch (_) {
+        console.error(chalk.bold.red(`It looks like you're trying to use TypeScript but do not have ${chalk.bold('typescript')} installed.`));
+        console.error(chalk.bold('Please install', chalk.cyan.bold('typescript'), 'by running', chalk.cyan.bold(isYarn ? 'yarn add typescript' : 'npm install typescript') + '.'));
+        console.error();
+        process.exit(1);
+    }
+    const compilerOptions = {
+        // These are suggested values and will be set when not present in the
+        // tsconfig.json
+        // 'parsedValue' matches the output value from ts.parseJsonConfigFileContent()
+        target: {
+            parsedValue: ts.ScriptTarget.ES5,
+            suggested: 'es5'
+        },
+        lib: { suggested: ['dom', 'dom.iterable', 'esnext'] },
+        allowJs: { suggested: true },
+        skipLibCheck: { suggested: true },
+        esModuleInterop: { suggested: true },
+        allowSyntheticDefaultImports: { suggested: true },
+        strict: { suggested: true },
+        forceConsistentCasingInFileNames: { suggested: true },
+        // TODO: Enable for v4.0 (#6936)
+        // noFallthroughCasesInSwitch: { suggested: true },
+        // These values are required and cannot be changed by the user
+        // Keep this in sync with the webpack config
+        module: {
+            parsedValue: ts.ModuleKind.ESNext,
+            value: 'esnext',
+            reason: 'for import() and import/export'
+        },
+        moduleResolution: {
+            parsedValue: ts.ModuleResolutionKind.NodeJs,
+            value: 'node',
+            reason: 'to match webpack resolution'
+        },
+        resolveJsonModule: { value: true, reason: 'to match webpack loader' },
+        isolatedModules: { value: true, reason: 'implementation limitation' },
+        paths: { value: undefined, reason: 'aliased imports are not supported' }
+    };
+    const formatDiagnosticHost = {
+        getCanonicalFileName: (fileName) => fileName,
+        getCurrentDirectory: ts.sys.getCurrentDirectory,
+        getNewLine: () => os.EOL
+    };
+    const messages = [];
+    let appTsConfig;
+    let parsedTsConfig;
+    let parsedCompilerOptions;
+    try {
+        const { config: readTsConfig, error } = ts.readConfigFile(paths.appTsConfig, ts.sys.readFile);
+        if (error) {
+            throw new Error(ts.formatDiagnostic(error, formatDiagnosticHost));
+        }
+        appTsConfig = readTsConfig;
+        // Get TS to parse and resolve any "extends"
+        // Calling this function also mutates the tsconfig above,
+        // adding in "include" and "exclude", but the compilerOptions remain untouched
+        let result;
+        parsedTsConfig = immer(readTsConfig, (config) => {
+            result = ts.parseJsonConfigFileContent(config, ts.sys, path.dirname(paths.appTsConfig));
+        });
+        if (result.errors && result.errors.length) {
+            throw new Error(ts.formatDiagnostic(result.errors[0], formatDiagnosticHost));
+        }
+        parsedCompilerOptions = result.options;
+    }
+    catch (e) {
+        if (e && e.name === 'SyntaxError') {
+            console.error(chalk.red.bold('Could not parse', chalk.cyan('tsconfig.json') + '.', 'Please make sure it contains syntactically correct JSON.'));
+        }
+        console.log(e && e.message ? `${e.message}` : '');
+        process.exit(1);
+    }
+    if (appTsConfig.compilerOptions == null) {
+        appTsConfig.compilerOptions = {};
+        firstTimeSetup = true;
+    }
+    for (const option of Object.keys(compilerOptions)) {
+        const { parsedValue, value, suggested, reason } = compilerOptions[option];
+        const valueToCheck = parsedValue === undefined ? value : parsedValue;
+        const coloredOption = chalk.cyan('compilerOptions.' + option);
+        if (suggested != null) {
+            if (parsedCompilerOptions[option] === undefined) {
+                appTsConfig.compilerOptions[option] = suggested;
+                messages.push(`${coloredOption} to be ${chalk.bold('suggested')} value: ${chalk.cyan.bold(suggested)} (this can be changed)`);
+            }
+        }
+        else if (parsedCompilerOptions[option] !== valueToCheck) {
+            appTsConfig.compilerOptions[option] = value;
+            messages.push(`${coloredOption} ${chalk.bold(valueToCheck == null ? 'must not' : 'must')} be ${valueToCheck == null ? 'set' : chalk.cyan.bold(value)}` + (reason != null ? ` (${reason})` : ''));
+        }
+    }
+    // tsconfig will have the merged "include" and "exclude" by this point
+    if (parsedTsConfig.include == null) {
+        appTsConfig.include = ['src'];
+        messages.push(`${chalk.cyan('include')} should be ${chalk.cyan.bold('src')}`);
+    }
+    if (parsedTsConfig.exclude == null) {
+        appTsConfig.exclude = ['src/_package'];
+        messages.push(`${chalk.cyan('exclude')} should have ${chalk.cyan.bold('src/_package')}`);
+    }
+    if (messages.length > 0) {
+        if (firstTimeSetup) {
+            console.log(chalk.bold('Your', chalk.cyan('tsconfig.json'), 'has been populated with default values.'));
+            console.log();
+        }
+        else {
+            console.warn(chalk.bold('The following changes are being made to your', chalk.cyan('tsconfig.json'), 'file:'));
+            messages.forEach((message) => {
+                console.warn('  - ' + message);
+            });
+            console.warn();
+        }
+        writeJson(paths.appTsConfig, appTsConfig);
+    }
+}
+module.exports = verifyTypeScriptSetup;

package/dist/lib/viewTemplate.d.ts

@@ -0,0 +1,6 @@
+declare const viewTemplate: ({ elmRoot, css, bundleHash, bundleName }: {
+    elmRoot: any;
+    css: any;
+    bundleHash: any;
+    bundleName: any;
+}) => string;

package/{lib → dist/lib}/viewTemplate.js

@@ -1,9 +1,5 @@
-const viewTemplate = ({
-  elmRoot,
-  css,
-  bundleHash,
-  bundleName
-}) => `function elmViewTemplate(model) {
+"use strict";
+const viewTemplate = ({ elmRoot, css, bundleHash, bundleName }) => `function elmViewTemplate(model) {
   var modelHTML =  model.__html ? model.__html : '';
   var staticPath = model.elmComponent.flags._staticPath;
   var flags = JSON.stringify(model.elmComponent.flags);
@@ -31,5 +27,4 @@ const viewTemplate = ({
     '});' +
   '</script>'
 }`;
-
 module.exports = viewTemplate;