Fix a lot of stuff

jsmnbom · jsmnbom · commit c2ed711cc627 · 2020-11-09T18:37:19.000+01:00
Found after report of DefinitelyTyped/DefinitelyTyped#49323
diff --git a/src/converter.ts b/src/converter.ts
@@ -44,6 +44,18 @@ const RESERVED = [
   'void',
   'while',
   'with',
+  'Date'
+];
+
+//
+const GLOBAL_TYPES = [
+  'ImageData',
+  'ArrayBuffer',
+  'ImageData',
+  'Element',
+  'Uint8Array',
+  'globalThis.Date',
+  'Window'
 ];
 
 // Types that are considered "simple"
@@ -379,22 +391,32 @@ export default class Converter {
       // Okay, apparently typescript doesn't need that, as all the namepaces are combined by the compiler
       //out += 'browser.';
     } else if (!this.namespaces[this.namespace].types!.find((x) => x.id === ref)) {
-      console.log(`Warning: Cannot find reference "${ref}", assuming the browser knows better.`);
-      // Add a type X = any, so the type can be used, but won't be typechecked
-      this.additionalTypes.push(`type ${ref} = any;`);
+      if (!GLOBAL_TYPES.includes(ref)) {
+        console.error(
+          `Cannot find reference "${ref}", fix or add tot GLOBAL_TYPES if browser knows it.`
+        );
+        // Add a type X = any, so the type can be used, but won't be typechecked
+        this.additionalTypes.push(`type ${ref} = any;`);
+      }
     }
     return ref;
   }
 
   convertType(type: TypeSchema, root = false): string {
     // Check if we've overridden it, likely for a type that can't be represented in json schema
+
+    if (type.converterAdditionalType) {
+      this.additionalTypes.push(type.converterAdditionalType);
+      if (type.converterTypeOverride) {
+        return type.converterTypeOverride;
+      }
+      if (type.id) {
+        return type.id;
+      }
+    }
     if (type.converterTypeOverride) {
       return type.converterTypeOverride;
     }
-    if (type.converterAdditionalType && type.id) {
-      this.additionalTypes.push(type.converterAdditionalType);
-      return type.id;
-    }
     let out = '';
     // Check type of type
     if (type.choices) {
@@ -513,19 +535,17 @@ export default class Converter {
           }
         } else if (type.isInstanceOf) {
           // It's an instance of another type
-          if (type.additionalProperties && type.additionalProperties.type === 'any') {
-            // The schemas write set additionalProperties.type = 'any' when typechecking can be anything
-            // This usually means it's "window" included as part of DOM
-            if (type.isInstanceOf.toLowerCase() === 'window') {
+          // Check if it's a window
+          if (type.isInstanceOf == 'global') {
+            out += 'Window';
+          } else {
+            // Check if it's a browser type
+            if (GLOBAL_TYPES.includes(type.isInstanceOf)) {
               out += type.isInstanceOf;
             } else {
-              // Otherwise it's some object we don't know about, therefore just treat it as a random
-              // object
-              out += `object/*${type.isInstanceOf}*/`;
+              // Other wise try to convert as ref
+              out += this.convertRef(type.isInstanceOf);
             }
-          } else {
-            // If the schema does not do that, try converting as a reference
-            out += this.convertRef(type.isInstanceOf);
           }
         } else if (type.additionalProperties) {
           // If it has additional, but not normal properties, try converting those properties as a type,
@@ -757,15 +777,19 @@ export default class Converter {
       if (callback) {
         // Remove callback from parameters as we're gonna handle it as a promise return
         func.parameters = func.parameters!.filter((x) => x !== callback);
-        let parameters = this.convertParameters(callback.parameters, false, pascalCase(`${func.name}_return`));
+        let parameters = this.convertParameters(
+          callback.parameters,
+          false,
+          pascalCase(`${func.name}_return`)
+        );
         if (parameters.length > 1) {
           // Since these files are originally chrome, some things are a bit weird
           // Callbacks (which is what chrome uses) have no issues with returning multiple values
           // but firefox uses promises, which AFAIK can't handle that
           // This doesn't seem to be a problem yet, as firefox hasn't actually implemented the methods in
           // question yet But since it's in the schemas, it's still a problem for us
           // TODO: Follow firefox developments in this area
-          console.log(`Warning: Promises cannot return more than one value: ${func.name}.`);
+          console.warn(`Promises cannot return more than one value: ${func.name}.`);
           // Just assume it's gonna be some kind of object that's returned from the promise
           // This seems like the most likely way the firefox team is going to make the promise return
           // multiple values
@@ -1034,14 +1058,13 @@ export default class Converter {
     delete this.namespaces[name];
   }
 
+  getIdOrName(type: TypeSchema) {
+    return type['id'] || type['name'] || type['$extend'] || type['$import'];
+  }
+
   getIndex(namespace: string, section: string, id_or_name: string): number {
     return (this.namespaces[namespace] as any)[section].findIndex((x: TypeSchema) => {
-      return (
-        x['id'] === id_or_name ||
-        x['name'] === id_or_name ||
-        x['$extend'] === id_or_name ||
-        x['$import'] === id_or_name
-      );
+      return this.getIdOrName(x) === id_or_name;
     });
   }
 
@@ -1052,7 +1075,12 @@ export default class Converter {
     );
   }
 
-  edit(namespace: string, section: string, id_or_name: string, edit: (x: any) => any) {
+  edit(
+    namespace: string,
+    section: string,
+    id_or_name: string,
+    edit: (type: TypeSchema) => TypeSchema
+  ) {
     console.log(`Editing ${namespace}.${section}.${id_or_name}`);
     const index = this.getIndex(namespace, section, id_or_name);
     const sectionObj = (this.namespaces[namespace] as any)[section];
@@ -1062,6 +1090,12 @@ export default class Converter {
     sectionObj[index] = edit(sectionObj[index]);
   }
 
+  add(namespace: string, section: string, value: TypeSchema) {
+    console.log(`Adding to ${namespace}.${section}.${this.getIdOrName(value)}`);
+    const sectionObj = (this.namespaces[namespace] as any)[section];
+    sectionObj.push(value);
+  }
+
   edit_path(path: [string, string, string] | string[], edit: (x: any) => any) {
     this.edit(path[0], path[1], path[2], edit);
   }
diff --git a/src/index.ts b/src/index.ts
@@ -23,7 +23,7 @@ const HEADER = `// Type definitions for non-npm package WebExtension Development
 // Project: https://developer.mozilla.org/en-US/Add-ons/WebExtensions
 // Definitions by: Jasmin Bom <https://github.com/jsmnbom>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.9
+// TypeScript Version: 3.4
 // Generated using script at github.com/jsmnbom/definitelytyped-firefox-webext-browser
 
 interface WebExtEvent<TCallback extends (...args: any[]) => any> {
@@ -32,10 +32,6 @@ interface WebExtEvent<TCallback extends (...args: any[]) => any> {
     hasListener(cb: TCallback): boolean;
 }
 
-interface Window {
-    browser: typeof browser;
-}
-
 `;
 
 let converter = new Converter(argv['_'], HEADER, NAMESPACE_ALIASES);
diff --git a/src/overrides.ts b/src/overrides.ts
@@ -4,6 +4,12 @@ export default function override(converter: Converter) {
   // Remove test namespace since it's not exposed in api
   converter.removeNamespace('test');
 
+  // Fix extensionTypes.Date
+  converter.edit('extensionTypes', 'types', 'Date', (Date) => {
+    Date.choices![2].isInstanceOf = 'globalThis.Date'
+    return Date;
+  })
+
   // browser.runtime.getManifest should return WebExtensionManifest
   converter.edit('runtime', 'functions', 'getManifest', (x) => {
     x.returns = { $ref: 'manifest.WebExtensionManifest' };
@@ -12,8 +18,8 @@ export default function override(converter: Converter) {
 
   // Fix dupe _NativeManifestType
   converter.edit('_manifest', 'types', 'NativeManifest', (x) => {
-    x.choices[0].properties.type.converterTypeOverride = '"pkcs11"| "stdio"';
-    x.choices[1].properties.type.converterTypeOverride = '"storage"';
+    x.choices![0].properties!.type.converterTypeOverride = '"pkcs11"| "stdio"';
+    x.choices![1].properties!.type.converterTypeOverride = '"storage"';
     return x;
   });
 
@@ -75,7 +81,7 @@ export default function override(converter: Converter) {
 
   // Additional fix for webrequest.onAuthRequired
   converter.edit('webRequest', 'events', 'onAuthRequired', (x) => {
-    x.parameters = x.parameters.filter((y: TypeSchema) => y.name !== 'callback');
+    x.parameters = x.parameters!.filter((y: TypeSchema) => y.name !== 'callback');
     return x;
   });
 
@@ -210,11 +216,11 @@ export default function override(converter: Converter) {
   }
 
   // Prevent some of Event from being promisified
-  converter.edit('events', 'types', 'Event', (x) => {
-    for (let f of x.functions.slice(0, 3)) {
+  converter.edit('events', 'types', 'Event', (Event) => {
+    for (let f of Event.functions!.slice(0, 3)) {
       f.async = false;
     }
-    return x;
+    return Event;
   });
 
   // Remove bookmarks.import and bookmarks.export as it breaks things
@@ -227,8 +233,8 @@ export default function override(converter: Converter) {
   // Fix runtime.Port.postMessage
   // https://github.com/DefinitelyTyped/DefinitelyTyped/issues/23542
   converter.edit('runtime', 'types', 'Port', (Port) => {
-    Port.properties.postMessage.parameters = [{ type: 'object', name: 'message' }];
-    Port.properties.error = { converterTypeOverride: 'Error', optional: true };
+    Port.properties!.postMessage.parameters = [{ type: 'object', name: 'message' }];
+    Port.properties!.error = { converterTypeOverride: 'Error', optional: true };
     Port.events = [
       {
         name: 'onMessage',
@@ -241,8 +247,8 @@ export default function override(converter: Converter) {
         parameters: [{ $ref: 'Port', name: 'port' }],
       },
     ];
-    delete Port.properties.onDisconnect;
-    delete Port.properties.onMessage;
+    delete Port.properties!.onDisconnect;
+    delete Port.properties!.onMessage;
 
     return Port;
   });
@@ -269,7 +275,7 @@ export default function override(converter: Converter) {
 
   // Fix error return type in some proxy events
   converter.edit('proxy', 'events', 'onError', (onError) => {
-    onError.parameters[0].converterTypeOverride = 'Error';
+    onError.parameters![0].converterTypeOverride = 'Error';
     return onError;
   });
 
@@ -279,14 +285,14 @@ export default function override(converter: Converter) {
     'PersistentBackgroundProperty',
     (PersistentBackgroundProperty) => {
       PersistentBackgroundProperty.type = 'boolean';
-      PersistentBackgroundProperty.deprecated = PersistentBackgroundProperty.choices[1].deprecated;
+      PersistentBackgroundProperty.deprecated = PersistentBackgroundProperty.choices![1].deprecated;
       delete PersistentBackgroundProperty.choices;
       return PersistentBackgroundProperty;
     }
   );
 
   converter.edit('permissions', 'functions', 'remove', (remove) => {
-    remove.parameters[1].parameters = [
+    remove.parameters![1].parameters = [
       {
         type: 'boolean',
       },
@@ -296,17 +302,118 @@ export default function override(converter: Converter) {
 
   // https://github.com/jsmnbom/definitelytyped-firefox-webext-browser/issues/35
   converter.edit('alarms', 'functions', 'get', (get) => {
-    get.parameters[1].converterPromiseOptional = true;
+    get.parameters![1].converterPromiseOptional = true;
     return get;
   });
 
   // These methods can return null for some reason
   converter.edit('cookies', 'functions', 'get', (get) => {
-    get.parameters[1].converterPromiseOptionalNull = true;
+    get.parameters![1].converterPromiseOptionalNull = true;
     return get;
   });
   converter.edit('cookies', 'functions', 'remove', (remove) => {
-    remove.parameters[1].converterPromiseOptionalNull = true;
+    remove.parameters![1].converterPromiseOptionalNull = true;
     return remove;
   });
+
+  // Add runtime.PlatformNaclArch
+  converter.add('runtime', 'types', {
+    id: 'PlatformNaclArch',
+    type: 'string',
+    enum: ['arm', 'x86-32', 'x86-64'],
+  });
+
+  // Add webrequest.StreamFilter
+  converter.add('webRequest', 'types', {
+    id: 'StreamFilter',
+    type: 'object',
+    description: 'An object you can use to monitor and modify HTTP responses.',
+    functions: [
+      {
+        name: 'close',
+        type: 'function',
+        description: 'Closes the request.',
+        async: 'callback',
+      },
+      {
+        name: 'disconnect',
+        type: 'function',
+        description: 'Disconnects the filter from the request.',
+        async: 'callback',
+      },
+      {
+        name: 'suspend',
+        type: 'function',
+        description: 'Suspends processing of the request.',
+        async: 'callback',
+      },
+      {
+        name: 'resume',
+        type: 'function',
+        description: 'Resumes processing of the request.',
+        async: 'callback',
+      },
+      {
+        name: 'write',
+        type: 'function',
+        description: 'Writes some data to the output stream.',
+        async: 'callback',
+        parameters: [
+          {
+            name: 'data',
+            choices: [{ $ref: 'Uint8Array' }, { $ref: 'ArrayBuffer' }],
+          },
+        ],
+      },
+    ],
+    properties: {
+      status: {
+        type: 'string',
+        description: 'Describes the current status of the stream.',
+        enum: [
+          'uninitialized',
+          'transferringdata',
+          'finishedtransferringdata',
+          'suspended',
+          'closed',
+          'disconnected',
+          'failed',
+        ],
+      },
+      error: {
+        type: 'string',
+        description:
+          'A string that will contain an error message after the onerror event has fired.',
+      },
+      onerror: {
+        description: 'Event handler which is called when an error has occurred.',
+        converterTypeOverride: '((event: Event) => void) | null',
+      },
+      onstop: {
+        description:
+          'Event handler which is called when the stream has no more data to deliver and has closed.',
+        converterTypeOverride: '((event: Event) => void) | null',
+      },
+      onstart: {
+        description:
+          'Event handler which is called when the stream is about to start receiving data.',
+        converterTypeOverride: '((event: Event) => void) | null',
+      },
+      ondata: {
+        description: 'Event handler which is called when incoming data is available.',
+        converterTypeOverride: '((event: _StreamFilterOndataEvent) => void) | null',
+        converterAdditionalType: 'interface _StreamFilterOndataEvent extends Event { data: ArrayBuffer }'
+      },
+    },
+  });
+  // converter.add('webRequest', 'types', {
+  //   type: 'object',
+  //   id: '_StreamFilterOndataEvent',
+  //   $extend: 'Event',
+  //   properties: {
+  //     data: {
+  //       $ref: 'ArrayBuffer'
+  //     }
+  //   }
+  // });
 }
diff --git a/src/types/converter.d.ts b/src/types/converter.d.ts
