2.0-beta.3

Author: zmh-program

cache.ts

@@ -13,34 +13,34 @@ class Cache {
     this.uptime();
   }
 
-  get(key: string): undefined | any {
+  get(key: string): undefined | any { //@ts-ignore
     const value = this.caches[key];
-    if (this.exist(key)) {
+    if (this.exist(key)) {  //@ts-ignore
       return JSON.parse(value.value);
     }
   }
 
-  set(key: string, value: any): void {
+  set(key: string, value: any): void {  //@ts-ignore
     this.caches[key] = {
       value: JSON.stringify(value),
       expiration: (new Date().getTime() / 1000) + this.expiration,
     }
   }
 
-  exist(key: string): boolean {
+  exist(key: string): boolean {  //@ts-ignore
     const value = this.caches[key];
     return (!!value) && (value.expiration > (new Date().getTime() / 1000));
   }
 
-  remove(key: string): boolean {
+  remove(key: string): boolean {  //@ts-ignore
     return delete this.caches[key];
   }
 
   uptime(): void {
     const _this = this;
     setInterval(function (){
       let n: number = 0;
-      for (const key in _this.caches) {
+      for (const key in _this.caches) {  //@ts-ignore
         if (_this.caches[key].expiration < (new Date().getTime() / 1000)) {
           _this.remove(key); n++;
         }

config.ts

@@ -1,6 +1,5 @@
-export default {
-  token: process.env.CODE_STATISTIC, // GitHub Access Token (Minimum permissions). Increase QPS of GitHub APIs.
-  expiration: 3600,  // expiration second
-  requires: ["*"], // CODE STATISTIC can only be parsed for allowed users. ( * indicates that all users are allowed )
-  port: 8000, // server port
-}
+
+export const token: string | undefined = process.env.CODE_STATISTIC; // GitHub Access Token (Minimum permissions). Increase QPS of GitHub APIs.
+export const expiration: number = 3600;  // expiration second
+export const requires: string[] = ["*"]; // CODE STATISTIC can only be parsed for allowed users. ( * indicates that all users are allowed )
+export const port: number =  8000; // server port

index.ts

@@ -38,6 +38,5 @@ app.get('/repo/:user/:repo/', async function (req: any, res: any) {
   }
 });
 
-
 app.listen(conf.port, () =>
   logger.info(`Starting deployment server at http://127.0.0.1:${conf.port}/.`));

stats.ts

@@ -7,49 +7,49 @@ const colors = {"1C Enterprise":"#814CCC","2-Dimensional Array":"#38761D","4D":"
 async function analysis(queue: Promise<object>[]) {
   const res: object = {};
   for (const idx in queue) {
-    const resp: object = await queue[idx];
+    const resp: object = await queue[idx]; //@ts-ignore
     for (const lang in resp) lang in res ? res[lang] += resp[lang] : res[lang] = resp[lang];
   }
   return formatter(res);
 }
 
 function formatter(langs: object): object[] {
   const arr: number[] = utils.sort(Object.values(langs)).reverse();
-  const total: number = utils.sum(arr);
+  const total: number = utils.sum(arr);  //@ts-ignore
   for (let k in langs) { langs[langs[k]] = k; delete langs[k] }
   let cursor: number = 0;
-  return arr.map((key: number): object => {
+  return arr.map((key: number): object => {  //@ts-ignore
     const lang: string = langs[key];
     const ratio: number = key / total; cursor += ratio;
-    return {
+    return {  //@ts-ignore
       name: lang,                color: colors[lang],
       cursor: cursor - ratio,    ratio: ratio,
       text: `${lang} ${(ratio * 100).toFixed(0)}% (${utils.decConvert(key, false)})`,
     }});
 }
 
-export async function getAccount(username, dark=false) {
-  const response = await cache.requestWithCache(`/users/${username}`);
+export async function getAccount(username: string, dark: boolean = false) {
+  const response = await utils.requestUser(username);
   const repos = await utils.listRepos(username);
   return {
     dark: dark,
     org: response['type'] !== 'User',
-    location: response['location'],
-    stars: utils.decConvert(utils.sum(repos.map(repo => repo['stargazers_count']))),
-    forks: utils.decConvert(utils.sum(repos.map(repo => repo['forks_count']))),
-    issues: utils.decConvert(utils.sum(repos.map(repo => repo['open_issues_count']))),
-    watchers: utils.decConvert(utils.sum(repos.map(repo => repo['watchers_count']))),
+    location: response['location'],  //@ts-ignore
+    stars: utils.decConvert(utils.sum(repos.map(repo => repo['stargazers_count']))),  //@ts-ignore
+    forks: utils.decConvert(utils.sum(repos.map(repo => repo['forks_count']))),  //@ts-ignore
+    issues: utils.decConvert(utils.sum(repos.map(repo => repo['open_issues_count']))),  //@ts-ignore
+    watchers: utils.decConvert(utils.sum(repos.map(repo => repo['watchers_count']))),  //@ts-ignore
     username: username,
     followers: utils.decConvert(response['followers']),
     repos: response['public_repos'],
-    langs: await analysis(
+    langs: await analysis(  //@ts-ignore
       repos.map(async (resp) => {
         return await utils.requestLanguage(username, resp['name']);
       })),
   };
 }
 
-export async function getRepository(username, repo, dark=false) {
+export async function getRepository(username: string, repo: string, dark: boolean = false) {
   const res = await utils.requestRepo(username, repo);
   return {
     dark : dark,
@@ -59,7 +59,7 @@ export async function getRepository(username, repo, dark=false) {
     forks: utils.decConvert(res['forks']),
     stars: utils.decConvert(res['stargazers_count']),
     watchers: utils.decConvert(res['watchers_count']),
-    license: utils.getLicense(res['license']),
+    license: utils.getLicense(res['license']),  //@ts-ignore
     color: colors[res['language']],
     langs: formatter(await utils.requestLanguage(username, repo)),
   };

utils.ts

@@ -52,8 +52,8 @@ export async function requestUser(user: string): Promise<any> {
     return await request(`/users/${user}`);
 }
 
-export async function listRepos(user: string): Promise<object> {
-    return Object.values(await request(`/users/${user}/repos`)).filter((repo: object): boolean => !repo['fork']);
+export async function listRepos(user: string): Promise<any> {
+    return Object.values(await request(`/users/${user}/repos`)).filter((repo: any): boolean => !repo['fork']);
 }
 
 export async function requestRepo(user: string, repo: string): Promise<any> {