Provide property types for public and protected properties (#1126)

Author: dbaeumer

src/extension/typescriptContext/serverPlugin/fixtures/testbed/src/company.ts

@@ -0,0 +1,43 @@
+import type { Employee } from './employee';
+import type { Name } from './entity';
+import type { EventProvider } from './eventProvider';
+import { LegalEntity, type RegistrationNumber } from './legalEntity';
+import type { Age } from './person';
+
+export class Company extends LegalEntity {
+
+	private employees: Employee[] = [];
+
+	constructor(companyName: Name, registrationNumber: RegistrationNumber) {
+		super(companyName, registrationNumber);
+	}
+
+	public listen(eventProvider: EventProvider): void {
+		eventProvider.onEmployeeAdded((employee: Employee) => {
+			this.addEmployee(employee);
+			
+		});
+	}
+
+	public addEmployee(employee: Employee): void {
+		this.employees.push(employee);
+
+	}
+
+	public getEmployee(name: string): Employee | undefined {
+		return this.employees.find(emp => emp.getName() === name);
+	}
+
+	public getAllEmployees(): Employee[] {
+		return this.employees;
+	}
+
+	public averageEmployeeAge(): number {
+		let totalAge = 0;
+		for (const employee of this.employees) {
+			const age: Age = employee.getAge();
+			totalAge += age.value;
+		}
+		return this.employees.length === 0 ? 0 : totalAge / this.employees.length;
+	}
+}

src/extension/typescriptContext/serverPlugin/fixtures/testbed/src/disposable.ts

@@ -0,0 +1,19 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+export interface Disposable {
+	/**
+	 * Dispose this object.
+	 */
+	dispose(): void;
+}
+
+export namespace Disposable {
+	export function create(func: () => void): Disposable {
+		return {
+			dispose: func
+		};
+	}
+}

src/extension/typescriptContext/serverPlugin/fixtures/testbed/src/employee.ts

@@ -0,0 +1,14 @@
+import { Person, type Age } from './person';
+
+export class Employee extends Person {
+	private employeeId: number;
+
+	constructor(name: string, age: Age, employeeId: number) {
+		super(name, age);
+		this.employeeId = employeeId;
+	}
+
+	getEmployeeDetails(): string {
+		return `ID: ${this.employeeId}, Name: ${this.getName()}, Age: ${this.getAge().value}`;
+	}
+}

src/extension/typescriptContext/serverPlugin/fixtures/testbed/src/entity.ts

@@ -0,0 +1,20 @@
+export class Name {
+	constructor(private _value: string) {
+		if (_value.trim().length === 0) {
+			throw new Error('Name cannot be empty.');
+		}
+	}
+	public get value(): string {
+		return this._value;
+	}
+}
+
+export class Entity {
+	
+	constructor(protected name: Name) {
+	}
+
+	getName(): Name {
+		return this.name;
+	}
+}

src/extension/typescriptContext/serverPlugin/fixtures/testbed/src/eventProvider.ts

@@ -0,0 +1,6 @@
+import type { Employee } from './employee';
+import type { Event } from './events';
+
+export interface EventProvider {
+	onEmployeeAdded: Event<Employee>;
+}

src/extension/typescriptContext/serverPlugin/fixtures/testbed/src/events.ts

@@ -0,0 +1,170 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+
+import { Disposable } from './disposable';
+
+/**
+ * Represents a typed event.
+ */
+export interface Event<T> {
+
+	/**
+	 *
+	 * @param listener The listener function will be called when the event happens.
+	 * @param thisArgs The 'this' which will be used when calling the event listener.
+	 * @param disposables An array to which a {{IDisposable}} will be added.
+	 * @return
+	*/
+	(listener: (e: T) => any, thisArgs?: any, disposables?: Disposable[]): Disposable;
+}
+
+export namespace Event {
+	const _disposable = { dispose() { } };
+	export const None: Event<any> = function () { return _disposable; };
+}
+
+class CallbackList {
+
+	private _callbacks: Function[] | undefined;
+	private _contexts: any[] | undefined;
+
+	public add(callback: Function, context: any = null, bucket?: Disposable[]): void {
+		if (!this._callbacks) {
+			this._callbacks = [];
+			this._contexts = [];
+		}
+		this._callbacks.push(callback);
+		this._contexts!.push(context);
+
+		if (Array.isArray(bucket)) {
+			bucket.push({ dispose: () => this.remove(callback, context) });
+		}
+	}
+
+	public remove(callback: Function, context: any = null): void {
+		if (!this._callbacks) {
+			return;
+		}
+
+		let foundCallbackWithDifferentContext = false;
+		for (let i = 0, len = this._callbacks.length; i < len; i++) {
+			if (this._callbacks[i] === callback) {
+				if (this._contexts![i] === context) {
+					// callback & context match => remove it
+					this._callbacks.splice(i, 1);
+					this._contexts!.splice(i, 1);
+					return;
+				} else {
+					foundCallbackWithDifferentContext = true;
+				}
+			}
+		}
+
+		if (foundCallbackWithDifferentContext) {
+			throw new Error('When adding a listener with a context, you should remove it with the same context');
+		}
+	}
+
+	public invoke(...args: any[]): any[] {
+		if (!this._callbacks) {
+			return [];
+		}
+
+		const ret: any[] = [],
+			callbacks = this._callbacks.slice(0),
+			contexts = this._contexts!.slice(0);
+
+		for (let i = 0, len = callbacks.length; i < len; i++) {
+			try {
+				ret.push(callbacks[i]!.apply(contexts[i], args));
+			} catch (e) {
+				// eslint-disable-next-line no-console
+				console.error(e);
+			}
+		}
+		return ret;
+	}
+
+	public isEmpty(): boolean {
+		return !this._callbacks || this._callbacks.length === 0;
+	}
+
+	public dispose(): void {
+		this._callbacks = undefined;
+		this._contexts = undefined;
+	}
+}
+
+export interface EmitterOptions {
+	onFirstListenerAdd?: Function;
+	onLastListenerRemove?: Function;
+}
+
+export class Emitter<T> {
+
+	private static _noop = function () { };
+
+	private _event: Event<T> | undefined;
+	private _callbacks: CallbackList | undefined;
+
+	constructor(private _options?: EmitterOptions) {
+	}
+
+	/**
+	 * For the public to allow to subscribe
+	 * to events from this Emitter
+	 */
+	get event(): Event<T> {
+		if (!this._event) {
+			this._event = (listener: (e: T) => any, thisArgs?: any, disposables?: Disposable[]) => {
+				if (!this._callbacks) {
+					this._callbacks = new CallbackList();
+				}
+				if (this._options && this._options.onFirstListenerAdd && this._callbacks.isEmpty()) {
+					this._options.onFirstListenerAdd(this);
+				}
+				this._callbacks.add(listener, thisArgs);
+
+				const result: Disposable = {
+					dispose: () => {
+						if (!this._callbacks) {
+							// disposable is disposed after emitter is disposed.
+							return;
+						}
+
+						this._callbacks.remove(listener, thisArgs);
+						result.dispose = Emitter._noop;
+						if (this._options && this._options.onLastListenerRemove && this._callbacks.isEmpty()) {
+							this._options.onLastListenerRemove(this);
+						}
+					}
+				};
+				if (Array.isArray(disposables)) {
+					disposables.push(result);
+				}
+
+				return result;
+			};
+		}
+		return this._event;
+	}
+
+	/**
+	 * To be kept private to fire an event to
+	 * subscribers
+	 */
+	fire(event: T): any {
+		if (this._callbacks) {
+			this._callbacks.invoke.call(this._callbacks, event);
+		}
+	}
+
+	dispose() {
+		if (this._callbacks) {
+			this._callbacks.dispose();
+			this._callbacks = undefined;
+		}
+	}
+}

src/extension/typescriptContext/serverPlugin/fixtures/testbed/src/legalEntity.ts

@@ -0,0 +1,22 @@
+import { Entity, type Name } from './entity';
+
+export class RegistrationNumber {
+	constructor(private _value: string) {
+		if (!/^[A-Z0-9]{8,12}$/.test(_value)) {
+			throw new Error('Registration number must be 8-12 alphanumeric characters.');
+		}
+	}
+	public get value(): string {
+		return this._value;
+	}
+}
+
+export class LegalEntity extends Entity {
+	constructor(name: Name, private registrationNumber: RegistrationNumber) {
+		super(name);
+	}
+
+	public getRegistrationNumber(): RegistrationNumber {
+		return this.registrationNumber;
+	}
+}

src/extension/typescriptContext/serverPlugin/fixtures/testbed/src/main.ts

@@ -0,0 +1,3 @@
+import { Age, Person } from "./person.js";
+
+const person = new Person("Dirk", new Age(42));

src/extension/typescriptContext/serverPlugin/fixtures/testbed/src/person.ts

@@ -0,0 +1,21 @@
+export class Age {
+	constructor(private _value: number) {
+		if (_value < 0 || _value > 150) {
+			throw new Error('Age must be between 0 and 150.');
+		}
+	}
+	public get value(): number {
+		return this._value;
+	}
+}
+
+export class Person {
+	constructor(private name: string, private age: Age) {
+	}
+	public getName(): string {
+		return this.name;
+	}
+	public getAge(): Age {
+		return this.age;
+	}
+}

src/extension/typescriptContext/serverPlugin/fixtures/testbed/tsconfig.json

@@ -0,0 +1,44 @@
+{
+  // Visit https://aka.ms/tsconfig to read more about this file
+  "compilerOptions": {
+    // File Layout
+    "rootDir": "./src",
+    "outDir": "./dist",
+
+    // Environment Settings
+    // See also https://aka.ms/tsconfig/module
+    "module": "nodenext",
+    "target": "esnext",
+    "types": [],
+    // For nodejs:
+    // "lib": ["esnext"],
+    // "types": ["node"],
+    // and npm install -D @types/node
+
+    // Other Outputs
+    "sourceMap": true,
+    "declaration": true,
+    "declarationMap": true,
+
+    // Stricter Typechecking Options
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+
+    // Style Options
+    // "noImplicitReturns": true,
+    // "noImplicitOverride": true,
+    // "noUnusedLocals": true,
+    // "noUnusedParameters": true,
+    // "noFallthroughCasesInSwitch": true,
+    // "noPropertyAccessFromIndexSignature": true,
+
+    // Recommended Options
+    "strict": true,
+    "jsx": "react-jsx",
+    "verbatimModuleSyntax": false,
+    "isolatedModules": true,
+    "noUncheckedSideEffectImports": true,
+    "moduleDetection": "force",
+    "skipLibCheck": true,
+  }
+}