first commit

app_vue/node_modules/@webassemblyjs/ast/scripts/generateNodeUtils.js

@@ -0,0 +1,219 @@
+const definitions = require("../src/definitions");
+const flatMap = require("array.prototype.flatmap");
+const {
+  typeSignature,
+  iterateProps,
+  mapProps,
+  filterProps,
+  unique,
+} = require("./util");
+
+const stdout = process.stdout;
+
+const jsTypes = ["string", "number", "boolean"];
+
+const quote = (value) => `"${value}"`;
+
+function params(fields) {
+  const optionalDefault = (field) =>
+    field.default ? ` = ${field.default}` : "";
+  return mapProps(fields)
+    .map((field) => `${typeSignature(field)}${optionalDefault(field)}`)
+    .join(",");
+}
+
+function assertParamType({ assertNodeType, array, name, type }) {
+  if (array) {
+    // TODO - assert contents of array?
+    return `assert(typeof ${name} === "object" && typeof ${name}.length !== "undefined")\n`;
+  } else {
+    if (jsTypes.includes(type)) {
+      return `assert(
+          typeof ${name} === "${type}",
+          "Argument ${name} must be of type ${type}, given: " + typeof ${name}
+      )`;
+    }
+
+    if (assertNodeType === true) {
+      return `assert(
+        ${name}.type === "${type}",
+        "Argument ${name} must be of type ${type}, given: " + ${name}.type
+      )`;
+    }
+
+    return "";
+  }
+}
+
+function assertParam(meta) {
+  const paramAssertion = assertParamType(meta);
+
+  if (paramAssertion === "") {
+    return "";
+  }
+
+  if (meta.maybe || meta.optional) {
+    return `
+      if (${meta.name} !== null && ${meta.name} !== undefined) {
+        ${paramAssertion};
+      }
+    `;
+  } else {
+    return paramAssertion;
+  }
+}
+
+function assertParams(fields) {
+  return mapProps(fields).map(assertParam).join("\n");
+}
+
+function buildObject(typeDef) {
+  const optionalField = (meta) => {
+    if (meta.array) {
+      // omit optional array properties if the constructor function was supplied
+      // with an empty array
+      return `
+        if (typeof ${meta.name} !== "undefined" && ${meta.name}.length > 0) {
+          node.${meta.name} = ${meta.name};
+        }
+      `;
+    } else if (meta.type === "Object") {
+      // omit optional object properties if they have no keys
+      return `
+        if (typeof ${meta.name} !== "undefined" && Object.keys(${meta.name}).length !== 0) {
+          node.${meta.name} = ${meta.name};
+        }
+      `;
+    } else if (meta.type === "boolean") {
+      // omit optional boolean properties if they are not true
+      return `
+        if (${meta.name} === true) {
+          node.${meta.name} = true;
+        }
+      `;
+    } else {
+      return `
+        if (typeof ${meta.name} !== "undefined") {
+          node.${meta.name} = ${meta.name};
+        }
+      `;
+    }
+  };
+
+  const fields = mapProps(typeDef.fields)
+    .filter((f) => !f.optional && !f.constant)
+    .map((f) => f.name);
+
+  const constants = mapProps(typeDef.fields)
+    .filter((f) => f.constant)
+    .map((f) => `${f.name}: "${f.value}"`);
+
+  return `
+    const node: ${typeDef.flowTypeName || typeDef.name} = {
+      type: "${typeDef.name}",
+      ${constants.concat(fields).join(",")}
+    }
+
+    ${mapProps(typeDef.fields)
+      .filter((f) => f.optional)
+      .map(optionalField)
+      .join("")}
+  `;
+}
+
+function lowerCamelCase(name) {
+  return name.substring(0, 1).toLowerCase() + name.substring(1);
+}
+
+function generate() {
+  stdout.write(`
+    // @flow
+
+    // THIS FILE IS AUTOGENERATED
+    // see scripts/generateNodeUtils.js
+
+    import { assert } from "mamacro";
+
+    function isTypeOf(t: string) {
+      return (n: Node) => n.type === t;
+    }
+
+    function assertTypeOf(t: string) {
+      return (n: Node) => assert(n.type === t);
+    }
+  `);
+
+  // Node builders
+  iterateProps(definitions, (typeDefinition) => {
+    stdout.write(`
+      export function ${lowerCamelCase(typeDefinition.name)} (
+        ${params(filterProps(typeDefinition.fields, (f) => !f.constant))}
+      ): ${typeDefinition.name} {
+
+        ${assertParams(filterProps(typeDefinition.fields, (f) => !f.constant))}
+        ${buildObject(typeDefinition)} 
+
+        return node;
+      }
+    `);
+  });
+
+  // Node testers
+  iterateProps(definitions, (typeDefinition) => {
+    stdout.write(`
+      export const is${typeDefinition.name}: ((n: Node) => boolean) =
+        isTypeOf("${typeDefinition.name}");
+    `);
+  });
+
+  // Node union type testers
+  const unionTypes = unique(
+    flatMap(
+      mapProps(definitions).filter((d) => d.unionType),
+      (d) => d.unionType
+    )
+  );
+  unionTypes.forEach((unionType) => {
+    stdout.write(
+      `
+      export const is${unionType} = (node: Node): boolean => ` +
+        mapProps(definitions)
+          .filter((d) => d.unionType && d.unionType.includes(unionType))
+          .map((d) => `is${d.name}(node) `)
+          .join("||") +
+        ";\n\n"
+    );
+  });
+
+  // Node assertion
+  iterateProps(definitions, (typeDefinition) => {
+    stdout.write(`
+      export const assert${typeDefinition.name}: ((n: Node) => void) =
+        assertTypeOf("${typeDefinition.name}");
+    `);
+  });
+
+  // a map from node type to its set of union types
+  stdout.write(
+    `
+    export const unionTypesMap = {` +
+      mapProps(definitions)
+        .filter((d) => d.unionType)
+        .map((t) => `"${t.name}": [${t.unionType.map(quote).join(",")}]\n`) +
+      `};
+      `
+  );
+
+  // an array of all node and union types
+  stdout.write(
+    `
+    export const nodeAndUnionTypes = [` +
+      mapProps(definitions)
+        .map((t) => `"${t.name}"`)
+        .concat(unionTypes.map(quote))
+        .join(",") +
+      `];`
+  );
+}
+
+generate();

app_vue/node_modules/@webassemblyjs/ast/scripts/generateTypeDefinitions.js

@@ -0,0 +1,48 @@
+const definitions = require("../src/definitions");
+const flatMap = require("array.prototype.flatmap");
+const { typeSignature, mapProps, iterateProps, unique } = require("./util");
+
+const stdout = process.stdout;
+
+function params(fields) {
+  return mapProps(fields).map(typeSignature).join(",");
+}
+
+function generate() {
+  stdout.write(`
+    // @flow
+    /* eslint no-unused-vars: off */
+
+    // THIS FILE IS AUTOGENERATED
+    // see scripts/generateTypeDefinitions.js
+  `);
+
+  // generate union types
+  const unionTypes = unique(
+    flatMap(
+      mapProps(definitions).filter((d) => d.unionType),
+      (d) => d.unionType
+    )
+  );
+  unionTypes.forEach((unionType) => {
+    stdout.write(
+      `type ${unionType} = ` +
+        mapProps(definitions)
+          .filter((d) => d.unionType && d.unionType.includes(unionType))
+          .map((d) => d.name)
+          .join("|") +
+        ";\n\n"
+    );
+  });
+
+  // generate the type definitions
+  iterateProps(definitions, (typeDef) => {
+    stdout.write(`type ${typeDef.name} = {
+        ...BaseNode,
+        type: "${typeDef.name}",
+        ${params(typeDef.fields)}
+      };\n\n`);
+  });
+}
+
+generate();

app_vue/node_modules/@webassemblyjs/ast/scripts/util.js

@@ -0,0 +1,38 @@
+function iterateProps(obj, iterator) {
+  Object.keys(obj).forEach((key) => iterator({ ...obj[key], name: key }));
+}
+
+function mapProps(obj) {
+  return Object.keys(obj).map((key) => ({ ...obj[key], name: key }));
+}
+
+function filterProps(obj, filter) {
+  const ret = {};
+  Object.keys(obj).forEach((key) => {
+    if (filter(obj[key])) {
+      ret[key] = obj[key];
+    }
+  });
+  return ret;
+}
+
+function typeSignature(meta) {
+  const type = meta.array ? `Array<${meta.type}>` : meta.type;
+  if (meta.optional) {
+    return `${meta.name}?: ${type}`;
+  } else if (meta.maybe) {
+    return `${meta.name}: ?${type}`;
+  } else {
+    return `${meta.name}: ${type}`;
+  }
+}
+
+const unique = (items) => Array.from(new Set(items));
+
+module.exports = {
+  iterateProps,
+  mapProps,
+  filterProps,
+  typeSignature,
+  unique,
+};