Merge pull request #35 from pedromdev/modifiers-v5

Properties Modifiers v5

packages/tests/package.json

@@ -4,7 +4,8 @@
   "private": true,
   "scripts": {
     "test": "npm run build && jest --no-cache",
-    "build": "rimraf ./dist && tspc"
+    "build": "rimraf ./dist && tspc",
+    "build:watch": "rimraf ./dist && tspc -w"
   },
   "repository": {
     "type": "git",

packages/tests/src/types/classConstructor.test.ts

@@ -17,12 +17,12 @@ describe("Class Constructor", () => {
         parameters: [
           {
             name: "foo",
-            modifiers: 0,
+            modifiers: Types.ModifierFlags.None,
             type: {kind: Types.TypeKind.String},
           },
           {
             name: "bar",
-            modifiers: 0,
+            modifiers: Types.ModifierFlags.None,
             type: {kind: Types.TypeKind.Number},
           },
         ],

packages/tests/src/types/propertyModifiers.test.ts

@@ -0,0 +1,60 @@
+import {getClassType, hasModifier, Reflective, Types} from "tsruntime";
+
+class Cls {
+  f!: string;
+  protected g!: string;
+  constructor() {
+  }
+}
+
+@Reflective
+abstract class SubCls extends Cls {
+  a!: string;
+  public b!: string;
+  protected c!: string;
+  private d!: string;
+  readonly e!: string;
+  override f!: string;
+  protected override readonly g!: string;
+  abstract h: string;
+  protected abstract i: string;
+  public readonly j!: string;
+
+  constructor() {
+    super();
+  }
+}
+
+function getProperty(name: string) {
+  const type = getClassType(SubCls);
+  return type.properties[name];
+}
+
+function matchModifiers(propName: string, expected: Types.ModifierFlags[]) {
+  for (const modifierFlag of expected) {
+    expect({
+      name: propName,
+      modifierFlag,
+      hasModifier: hasModifier(getProperty(propName) as any as {modifiers: number}, modifierFlag)
+    }).toEqual({
+      name: propName,
+      modifierFlag,
+      hasModifier: true
+    });
+  }
+}
+
+describe("class properties modifiers", () => {
+  it("matches modifiers", () => {
+    matchModifiers("a", [Types.ModifierFlags.None]);
+    matchModifiers("b", [Types.ModifierFlags.Public]);
+    matchModifiers("c", [Types.ModifierFlags.Protected]);
+    matchModifiers("d", [Types.ModifierFlags.Private]);
+    matchModifiers("e", [Types.ModifierFlags.Readonly]);
+    matchModifiers("f", [Types.ModifierFlags.Override]);
+    matchModifiers("g", [Types.ModifierFlags.Protected, Types.ModifierFlags.Readonly, Types.ModifierFlags.Override]);
+    matchModifiers("h", [Types.ModifierFlags.Abstract]);
+    matchModifiers("i", [Types.ModifierFlags.Protected, Types.ModifierFlags.Abstract]);
+    matchModifiers("j", [Types.ModifierFlags.Public, Types.ModifierFlags.Readonly]);
+  });
+});

packages/tsruntime/src/runtime/hasModifier.ts

@@ -0,0 +1,8 @@
+import { ModifierFlags } from './publicTypes';
+
+export const hasModifier = (type: { modifiers: number }, modifier: ModifierFlags) => {
+  if (modifier === type.modifiers) {
+    return true;
+  }
+  return !!(type.modifiers & modifier);
+}

packages/tsruntime/src/runtime/index.ts

@@ -1,6 +1,7 @@
 export * from './reflect'
 export * from './classUtils'
 export * from './common'
+export * from './hasModifier'
 
 import * as Types from './publicTypes';
-export {Types}
+export {Types}

packages/tsruntime/src/runtime/publicTypes.ts

@@ -1,6 +1,32 @@
-import { ModifierFlags } from "typescript";
-
-export { ModifierFlags } from "typescript";
+export enum ModifierFlags {
+  None = 0,
+  Public = 1,
+  Private = 2,
+  Protected = 4,
+  Readonly = 8,
+  Override = 16,
+  Export = 32,
+  Abstract = 64,
+  Ambient = 128,
+  Static = 256,
+  Accessor = 512,
+  Async = 1024,
+  Default = 2048,
+  Const = 4096,
+  In = 8192,
+  Out = 16384,
+  Decorator = 32768,
+  Deprecated = 65536,
+  HasComputedJSDocModifiers = 268435456,
+  HasComputedFlags = 536870912,
+  AccessibilityModifier = 7,
+  ParameterPropertyModifier = 31,
+  NonPublicAccessibilityModifier = 6,
+  TypeScriptModifier = 28895,
+  ExportDefault = 2080,
+  All = 131071,
+  Modifier = 98303,
+}
 
 export enum TypeKind {
   Any = 1,

packages/tsruntime/src/transform/reflect.ts

@@ -141,7 +141,7 @@ export function getReflect(ctx: Ctx) {
     const decl = sym.declarations![0];
     const type = ctx.checker.getTypeOfSymbolAtLocation(sym, ctx.node);
     const serializedType = reflectType(type);
-    const modifierFlags = ts.getCombinedModifierFlags(decl);
+    const modifiers = ts.getCombinedModifierFlags(decl);
 
     const name = getPropertyName(sym);
     const initializer = ts.isPropertyDeclaration(sym.valueDeclaration!)
@@ -150,7 +150,7 @@ export function getReflect(ctx: Ctx) {
 
     return {
       name: name,
-      modifiers: modifierFlags,
+      modifiers,
       type: {...serializedType, initializer},
     };
   }

packages/tsruntime/tsconfig.json

@@ -2,9 +2,10 @@
 {
     "extends": "../../tsconfig.json",
     "compilerOptions": {
-        "outDir": "dist",
+        "lib": ["dom", "es2016"],
+        "outDir": "dist"
     },
     "include": [
         "src/**/*"
     ]
-}
+}