clasp-types/dist/index.js

A d.ts generator for clasp projects

#!/usr/bin/env node
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
var program = require('commander');
var TypeDoc = __importStar(require("typedoc"));
var ts = __importStar(require("typescript"));
var fs = __importStar(require("fs-extra"));
var LibraryBuilder_1 = require("./lib/builders/LibraryBuilder");
var ClientSideBuilder_1 = require("./lib/builders/ClientSideBuilder");
var ReadmeBuilder_1 = require("./lib/builders/ReadmeBuilder");
var LicenseBuilder_1 = require("./lib/builders/LicenseBuilder");
var typedocApp = new TypeDoc.Application();
typedocApp.options.addReader(new TypeDoc.TSConfigReader());
typedocApp.options.addReader(new TypeDoc.TypeDocReader());
typedocApp.bootstrap({
    mode: 'file',
    logger: 'none',
    target: ts.ScriptTarget.ES5,
    module: ts.ModuleKind.CommonJS,
    types: [],
    experimentalDecorators: true,
    ignoreCompilerErrors: true,
    excludeExternals: true
});
program
    .description("Generate d.ts for clasp projects. File [.clasp.json] required")
    .option('-s, --src <folder>', 'Source folder', 'src')
    .option('-o, --out <folder>', 'Output folder', 'dist')
    .option('-g, --client', 'Generate client side API types', false)
    .option('-r, --root <folder>', 'Root folder of [.clasp.json] and [package.json] files', '.')
    .parse(process.argv);
var rootDir = program.root;
var srcDir = rootDir + "/" + program.src;
var outDir = rootDir + "/" + program.out;
var gsRun = program.client;
var filename = 'index.d.ts';
//Load .clasp.json
var claspJsonPath = rootDir + "/.clasp.json";
var claspJson;
try {
    claspJson = JSON.parse(fs.readFileSync(claspJsonPath).toString());
}
catch (error) {
    console.log(claspJsonPath + " NOT found!");
    process.exit(1);
}
//Load package.json
var packageJsonPath = rootDir + "/package.json";
var packageJson;
try {
    packageJson = JSON.parse(fs.readFileSync(packageJsonPath).toString());
}
catch (error) {
    console.log(packageJsonPath + " NOT found!");
    process.exit(1);
}
var files = typedocApp.expandInputFiles([srcDir]);
var project = typedocApp.convert(files);
if (project) {
    var apiModelFilePath = outDir + "/.clasp-types-temp-api-model__.json";
    try {
        //Generate api model
        typedocApp.generateJson(project, apiModelFilePath);
        //Generate types
        var rawdata = fs.readFileSync(apiModelFilePath);
        var rootTypedoKind = JSON.parse(rawdata.toString());
        if (gsRun) {
            getGSRunTypes(rootTypedoKind);
        }
        else {
            generateLibraryTypes(rootTypedoKind);
        }
    }
    finally {
        //Tear down
        fs.remove(apiModelFilePath);
    }
}
else {
    console.log('Error reading .ts source files');
    process.exit(1);
}
function generateLibraryTypes(rootTypedoKind) {
    if (!claspJson.library || !claspJson.library.name || !claspJson.library.namespace) {
        console.log('ERROR - Add library info to .clasp.json. Example:');
        console.log();
        console.log(JSON.stringify({
            "scriptId": "xxxx",
            "rootDir": "./src",
            "library": {
                "namespace": "bkper",
                "name": "BkperApp"
            }
        }, null, 2));
        console.log();
        console.log('...or run with --client option to generate google.script.run d.ts files');
        console.log();
        return;
    }
    packageJson.name = packageJson.name + "-types";
    packageJson.description = "Typescript definitions for " + claspJson.library.name;
    packageJson.scripts = {};
    packageJson.devDependencies = {};
    packageJson.license = 'MIT';
    if (packageJson.dependencies) {
        for (var key in packageJson.dependencies) {
            packageJson.dependencies[key] = '*';
        }
    }
    packageJson.types = "./" + filename;
    fs.outputFileSync(outDir + "/" + packageJson.name + "/package.json", JSON.stringify(packageJson, null, 2));
    //README.md
    var readmeBuilder = new ReadmeBuilder_1.ReadmeBuilder(packageJson, claspJson);
    fs.outputFileSync(outDir + "/" + packageJson.name + "/README.md", readmeBuilder.build().getText());
    //LICENSE
    var licenseBuilder = new LicenseBuilder_1.LicenseBuilder(packageJson);
    fs.outputFileSync(outDir + "/" + packageJson.name + "/LICENSE", licenseBuilder.build().getText());
    //Library
    var builder = new LibraryBuilder_1.LibraryBuilder(rootTypedoKind, claspJson, packageJson);
    var filepath = outDir + "/" + packageJson.name + "/" + filename;
    fs.outputFileSync(filepath, builder.build().getText());
    console.log("Generated " + claspJson.library.name + " definitions at " + outDir + "/");
}
/**
 * Generate google.script.run d.ts file
 */
function getGSRunTypes(rootTypedoKind) {
    var builder = new ClientSideBuilder_1.ClientSideBuilder(rootTypedoKind);
    var filepath = outDir + "/@types/google.script.types/" + filename;
    fs.outputFileSync(filepath, builder.build().getText());
    console.log("Generated google.script.types definitions at " + outDir + "/@types/");
}