type ListItem = string | number;

function create10List(item: ListItem) {
  const arr: ListItem[] = [];
  for (let i = 0; i < 10; i++) {
    arr.push(item);
  }
  return arr;
}


3.3_example_aliases.ts

// @ts-nocheck

function hello(name: any): any {
  return `Hello ${name}!`;
}

function substring(str: any, start: any, end: any) {
  return null;
}

type Person = any;
const person: Person = {
  name: 'Hayden',
};


3.3_example_any.ts

function hello(name: string): string {
  return `Hello ${name}!`;
}


3.3_example_functions.ts

function create10List(item: string | number) {
  const arr: Array<string | number> = [];
  for (let i = 0; i < 10; i++) {
    arr.push(item);
  }
  return arr;
}


3.3_example_lists.ts

type visibility = 'Private' | 'Public';

function createChannel(name: string, visibility: visibility) {
  // Do things
}


3.3_example_literals.ts

type Person = {
  name: string;
  age?: number;
  height?: number;
}

const person: Person = {
  name: 'Hayden',
};

person.age = 5;


3.3_example_objects.ts

// Note:
//   end?: number
// = end: number | undefined

function substring(str: string, start: number, end?: number) {
  let newString = '';
  const modifiedEnd = end || str.length;
  // ^ What about end ?? str.length
  for (let i = start; i < modifiedEnd; i++) {
    newString += str[i];
  }
  return newString;
}

console.log(substring('hayden', 0, 3));
console.log(substring('hayden', 2));


3.3_example_optionals.ts

function printIfReady(ready: boolean | number) {
  if (ready === true || ready !== 0) {
    console.log('Ready!');
  }
}
printIfReady(1);
printIfReady(2);
printIfReady(0);
printIfReady(true);
printIfReady(false);


3.3_example_unions.ts

image: comp1531/basic:latest

stages:
  - checks

testing:
  stage: checks
  script:
    - npm run test

typecheck:
  stage: checks
  script:
    - npm run tsc


3.3_gitlab-ci_type.yml

function manyString(repeat, str) {
  let outString = '';
  for (let i = 0; i < repeat; i++) {
    outString += str;
  }
  return outString;
}
console.log(manyString('hello ', 5));


3.3_many_string_rude.js

3.3_many_string_runtime.js

function sum(a: number, b: number) {
  return a + b;
}
console.log(sum(1, 2));


3.3_mycode.ts

function manyString(repeat: number, str: string) {
  let outString = '';
  for (let i = 0; i < repeat; i++) {
    outString += str;
  }
  return outString;
}
console.log(manyString('hello ', 5));


3.3_mycode_broken.ts

image: comp1531/basic:latest

cache:
  paths:
    - node_modules
    
stages:
  - checks

testing:
  stage: checks
  script:
    - npm run test

typecheck:
  stage: checks
  script:
    - npm run tsc

linting:
  stage: checks
  script:
    - npm run lint


3.4_gitlab-ci_lint.yml

/* eslint-disable */
function a(b,c){
 let d = '';
  for
   (let i = 0; i < b; i++) 
d += c;
 return d;
}
console.log(a(5, 'hello '));


3.4_style_bad.js

function manyString(repeat, str) {
  let outString = '';
  for (let i = 0; i < repeat; i++) {
    outString += str;
  }
  return outString;
}
console.log(manyString(5, 'hello '));


3.4_style_good.js

type Fmtr = (str: string) => string;

function brackets(str: string) {
  return `(${str})`;
}

function fullstop(str: string) {
  return `${str}.`;
}

function sayHi(name: string, format: Fmtr) {
  return `Hello, ${format(name)}!`;
}

const result = sayHi('Hayden', brackets) +
             ' -- ' +
             sayHi('Hayden', fullstop);

console.log(result);


4.1_fcf_format_atomic.ts

type Fmtr = (str: string) => string;

const brackets = (str: string) => `(${str})`;
const fullstop = (str: string) => `${str}.`;
const sayHi = (name: string, format: Fmtr) => `Hello, ${format(name)}!`;

const result = sayHi('Hayden', brackets) +
             ' -- ' +
             sayHi('Hayden', fullstop);

console.log(result);


4.1_fcf_format_atomic_alt.ts

type Fmtr = (str: string) => string;

function brackets(str: string) {
  return `(${str})`;
}

const names = ['Hayden', 'Giuliana', 'Tam'];

function formatNames(list: string[], format: Fmtr) {
  const newList = [];
  for (const name of list) {
    newList.push(format(name));
  }
  return newList;
}

const newNames = formatNames(names, brackets);
console.log(newNames);


4.1_fcf_format_loop.ts

type Fmtr = (str: string) => string;

const names = ['Hayden', 'Giuliana', 'Tam'];

function formatNames(list: string[], format: Fmtr) {
  const newList = [];
  for (const name of list) {
    newList.push(format(name));
  }
  return newList;
}

const newNames = formatNames(names, (str) => {
  return `(${str})`;
});

console.log(newNames);


4.1_fcf_format_loop_anon.ts

type Fmtr = (str: string) => string;

const brackets = (str: string) => {
  return `(${str})`;
};

const names = ['Hayden', 'Giuliana', 'Tam'];

function formatNames(list: string[], format: Fmtr) {
  const newList: string[] = [];
  for (const name of list) {
    newList.push(format(name));
  }
  return newList;
}

const newNames = formatNames(names, brackets);
console.log(newNames);


4.1_fcf_format_loop_new.ts

const sayHi = (name: string) => {
  return `Hello ${name}!`;
};
console.log(sayHi('Hayden'));


4.1_fcf_var.ts

const marks = [65, 72, 81, 40, 56];

const isPass = function(mark: number) {
  return mark >= 50;
};

const newList = marks.filter(isPass);
console.log(newList);


4.1_filter.ts

4.1_filter_old.ts

const marks = [65, 72, 81, 40, 56];
const newList = marks.filter((mark) => mark >= 50);
console.log(newList);


4.1_filter_stream.ts

4.1_fn_syntax_1.js

function sum(a: number, b: number) {
  return a + b;
}


4.1_fn_syntax_1.ts

const sum = function(a, b) {
  return a + b;
};


4.1_fn_syntax_2.js

const sum = function(a: number, b: number) {
  return a + b;
};


4.1_fn_syntax_2.ts

const sum = (a, b) => {
  return a + b;
};


4.1_fn_syntax_3.js

const sum = (a: number, b: number) => {
  return a + b;
};


4.1_fn_syntax_3.ts

const sum = (a: number, b: number) => a + b;

// so short!!


4.1_fn_syntax_3_compact.ts

4.1_hoc_1.ts

4.1_hoc_2.ts

4.1_hoc_3.ts

4.1_hoc_4.ts

4.1_hoc_5.ts

4.1_hoc_6.ts

const genCongratMark = (markstr: string) => (name: string) =>
  `Congratulations ${name} on your ${markstr}`;

const congratMarkPS = genCongratMark('pass');
const congratMarkCR = genCongratMark('credit');
const congratMarkDN = genCongratMark('distinction');

console.log(congratMarkCR('Hayden'));


4.1_hoc_7.ts

function manyString(repeat: number, str: string) {
  let outString = '';
  for (let i = 0; i < repeat; i++) {
    outString += str;
  }
  return outString;
}
console.log(manyString(5, 'hello '));


4.1_many_string_1.ts

const manyString = function(repeat: number, str: string) {
  let outString = '';
  for (let i = 0; i < repeat; i++) {
    outString += str;
  }
  return outString;
};
console.log(manyString(5, 'hello '));


4.1_many_string_2.ts

const manyString = (repeat: number, str: string) => {
  let outString = '';
  for (let i = 0; i < repeat; i++) {
    outString += str;
  }
  return outString;
};
console.log(manyString(5, 'hello '));


4.1_many_string_3.ts

const tutors = [
  'Simon',
  'Teresa',
  'Kaiqi',
  'Michelle',
];

const shout = function(str: string) {
  return `${str.toUpperCase()}!!!`;
};

const newList = tutors.map(shout);
console.log(newList);


4.1_map.ts

4.1_map_old.ts

const tutors = ['Simon', 'Teresa', 'Kaiqi', 'Michelle'];
const newList = tutors.map((string) => `${string.toUpperCase()}!!!`);
console.log(newList);


4.1_map_stream.ts

const marks = [39, 43.2, 48.6, 24, 33.6];
const normalisedMarks = marks.map(m => 100 * m / 60);
const passingMarks = normalisedMarks.filter(m => m >= 50);
const total = passingMarks.reduce((a, b) => a + b, 0);
const average = total / passingMarks.length;
console.log(average);


4.1_mapfilterreduce.ts

import fs from 'fs';

function handleFile(error: any, data: any) {
  if (error) {
    console.error(error);
  } else {
    console.log(data);
  }
}

fs.readFile('dummy.txt', { flag: 'r' }, handleFile);

console.log('Finished!');


4.1_read_async.ts

import fs from 'fs';

const data = fs.readFileSync('dummy.txt', { flag: 'r' });

console.log(data);
console.log('Finished!');


4.1_read_sync.ts

type Student = {
  name: string;
  mark: number;
}

const students: Student[] = [
  { name: 'Amy', mark: 55 },
  { name: 'Bob', mark: 43 },
  { name: 'Cap', mark: 34 },
  { name: 'Dex', mark: 23 },
];

const sum = (prev: number, curr: Student) => {
  return prev + curr.mark;
};

const single = students.reduce(sum, 0);
console.log(single);


4.1_reduce.ts

4.1_reduce_old.ts

4.1_reduce_stream.ts

import express from 'express';

const app = express();
const port = 3001;

app.use(express.text());

app.get('/apple', (req, res) => {
  const name = req.query.name;
  res.send(JSON.stringify({
    msg: `Hi ${name}, thanks for sending apple!`,
  }));
});

// same for .put and .delete
app.post('/orange', (req, res) => {
  const body = JSON.parse(req.body);
  const name = body.name;
  res.send(JSON.stringify({
    msg: `Hi ${name}, thanks for sending orange!`,
  }));
});

app.listen(port, () => {
  console.log(`Listening on port ${port}`);
});


4.2_crud.ts

import express from 'express';

const app = express();
const port = 3001;

app.use(express.json());

app.get('/apple', (req, res) => {
  const name = req.query.name;
  res.json({
    msg: `Hi ${name}, thanks for sending apple!`,
  });
});

// same for .put and .delete
app.post('/orange', (req, res) => {
  const name = req.body.name;
  res.json({
    msg: `Hi ${name}, thanks for sending orange!`,
  });
});

app.listen(port, () => {
  console.log(`Listening on port ${port}`);
});


4.2_crud_json.ts

import express from 'express';

const app = express();
const port = 3000;

app.use(express.text());

app.get('/', (req, res) => {
  res.send('Hello World!');
});

app.listen(port, () => {
  console.log(`Listening on port ${port}`);
});


4.2_express_basic.ts

import request from 'sync-request';

describe('Test Apple', () => {
  test('If it returns a name string successfully', () => {
    const res = request(
      'GET',
      'http://localhost:3001/apple',
      {
        qs: {
          name: 'Hayden',
        },
      }
    );
    const bodyObj = JSON.parse(String(res.getBody()));
    expect(bodyObj.msg).toBe('Hi Hayden, thanks for sending apple!');
  });
});
describe('Test Orange', () => {
  test('If it returns a name string successfully', () => {
    const res = request(
      'POST',
      'http://localhost:3001/orange',
      {
        body: JSON.stringify({ name: 'Hayden' }),
        headers: {
          'Content-type': 'application/json',
        },
      }
    );
    const bodyObj = JSON.parse(String(res.getBody()));
    expect(bodyObj.msg).toBe('Hi Hayden, thanks for sending orange!');
  });
});


4.2_requests.test.ts

import request from 'sync-request';

const res = request(
  'GET',
  'http://localhost:3001/apple?name=Hayden'
);
console.log(JSON.parse(String(res.getBody())));


4.2_requests.ts

import request from 'sync-request';

describe('Test Apple', () => {
  test('If it returns a name string successfully', () => {
    const res = request(
      'GET',
      'http://localhost:3001/apple',
      {
        qs: {
          name: 'Hayden',
        },
      }
    );
    const bodyObj = JSON.parse(String(res.getBody()));
    expect(bodyObj.msg).toBe('Hi Hayden, thanks for sending apple!');
  });
});
describe('Test Orange', () => {
  test('If it returns a name string successfully', () => {
    const res = request(
      'POST',
      'http://localhost:3001/orange',
      {
        json: { name: 'Hayden' },
      }
    );
    const bodyObj = JSON.parse(String(res.getBody()));
    expect(bodyObj.msg).toBe('Hi Hayden, thanks for sending orange!');
  });
});


4.2_requests_json.test.ts

function dateNow() {
  return new Date().toISOString();
}

console.log(dateNow());


5.3_benign.ts


function loop(count: number, callback: (num: number) => void) {
  for (let i = 0; i < count; i++) {
    callback(i);
  }
}

loop(5, console.log);
loop(7, console.log);


5.3_benign2.ts

import { argv } from 'process';

if (argv.length !== 3) {
  process.exit(1);
}

const num = parseInt(argv[2], 10);

if (num === 2) {
  for (let i = 10; i < 20; i++) {
    const result = Math.pow(i, 2);
    console.log(`${i} ** 2 = ${result}`);
  }
} else if (num === 3) {
  for (let i = 10; i < 20; i++) {
    const result = i ** 3;
    console.log(`${i} ** 3 = ${result}`);
  }
} else {
  process.exit(1);
}


5.3_dry_dirty.ts

import { sqrt } from './5.2_sqrt';

describe('sqrt correctness', () => {
  test('deals with valid bases', () => {
    expect(sqrt(4)).toEqual(2);
    expect(sqrt(2)).toBeCloseTo(1.414213, 5);
  });
  test('throws error on negatives', () => {
    // Note that these require a function, not result
    expect(() => sqrt(-2)).toThrow('Error: Input < 0');
    expect(() => sqrt(-5)).toThrowError('Error: Input < 0');
  });
});


5.4_catch.test.ts

import prompt from 'prompt-sync';
const promptFn = prompt();

function sqrt(x: number) {
  if (x < 0) {
    throw new Error('Error Input < 0');
  }
  return Math.pow(x, 0.5);
}

const input = promptFn('Please enter a number: ');
console.log(sqrt(parseInt(input)));


5.4_exception1.ts

import prompt from 'prompt-sync';
const promptFn = prompt();

function sqrt(x: number) {
  if (x < 0) {
    throw new Error('Error Input < 0');
  }
  return Math.pow(x, 0.5);
}

try {
  const input = promptFn('Please enter a number: ');
  console.log(sqrt(parseInt(input)));
} catch (err) {
  console.error(`Error when inputting! ${err}`);
  const input = promptFn('Please enter a number: ');
  console.log(sqrt(parseInt(input)));
}


5.4_exception2.ts

import prompt from 'prompt-sync';
const promptFn = prompt();

function sqrt(x: number) {
  if (x < 0) {
    throw new Error('Error Input < 0');
  }
  return Math.pow(x, 0.5);
}

let success = false;
while (!success) {
  try {
    const input = promptFn('Please enter a number: ');
    console.log(sqrt(parseInt(input)));
    success = true;
  } catch (err) {
    console.error(`Error when inputting! ${err}`);
  }
}


5.4_exception3.ts

import prompt from 'prompt-sync';
const promptFn = prompt();

function sqrt(x: number) {
  if (x < 0) {
    console.error('Error Input < 0');
    process.exit(1);
  }
  return Math.pow(x, 0.5);
}

const input = promptFn('Please enter a number: ');
console.log(sqrt(parseInt(input)));


5.4_just_crash.ts

function sqrt(x: number) {
  if (x < 0) {
    throw new Error('Error Input < 0');
  }
  return Math.pow(x, 0.5);
}

export { sqrt };


5.4_sqrt.ts

5.4_throw_catch.ts

// Given a number of days from
// January 1st 1970, return the year.

import { isLeapYear } from './7.1_is_leap_year';

function dayToyear(days: number) {
  let year = 1970;

  while (days > 365) {
    if (isLeapYear(year)) {
      if (days > 366) {
        days -= 366;
        year += 1;
      }
    } else {
      days -= 365;
      year += 1;
    }
  }

  return year;
}


7.1_day_to_year.ts

export function isLeapYear(year: number) {
  if (year % 4 !== 0) {
    return false;
  } else if (year % 100 !== 0) {
    return true;
  } else if (year % 400 !== 0) {
    return false;
  } else {
    return true;
  }
}


7.1_is_leap_year.ts

/* eslint-disable no-unreachable */
import express from 'express';

const app = express();
const port = 3001;

app.get('/goerror', (req, res) => {
  throw new Error('Error, oh no!');
  res.send('Probably won\'t get this message');
});

app.listen(port, () => {
  console.log(`Listening on port ${port}`);
});


8.1_express_error_1.ts

import request from 'sync-request';

describe('Test Apple', () => {
  test('If it returns a name string successfully', () => {
    const res = request(
      'GET',
      'http://localhost:3001/hello',
      {}
    );
    const bodyObj = JSON.parse(String(res.getBody()));
    expect(bodyObj.msg).toBe('Hello there!');
  });
});


8.1_express_error_2.test.ts

/* eslint-disable no-unreachable */

import express from 'express';
import HTTPError from 'http-errors';
import errorHandler from 'middleware-http-errors';

const app = express();
const port = 3001;

app.use(express.json());

app.get('/goerror', (req, res) => {
  throw HTTPError(400, 'Error, oh no!');
  res.send('Probably won\'t get this message');
});

app.get('/hello', (req, res) => {
  res.json({ msg: 'Hello there!' });
});

app.use(errorHandler());

app.listen(port, () => {
  console.log(`Listening on port ${port}`);
});


8.1_express_error_2.ts

import express from 'express';

const app = express();
const port = 3001;

app.use('/static', express.static('static'));

app.listen(port, () => {
  console.log(`Listening on port ${port}`);
});


8.4_img_serve.ts

import request from 'sync-request';
import fs from 'fs';

const res = request(
  'GET',
  'http://www.traveller.com.au/content/dam/images/h/1/p/q/1/k/image.related.articleLeadwide.620x349.h1pq27.png/1596176460724.jpg'
);
const body = res.getBody();
fs.writeFileSync('test.jpg', body, { flag: 'w' });


8.4_pull_img.ts

const time = 3;
console.log(`Standup start for ${time} seconds!`);
function finishStandup() {
  console.log('Standup is now over');
}
setTimeout(finishStandup, time * 1000);


8.4_timeout.ts

type Data = {
  users: { [email: string]: string };
};

import { getHashOf } from './9.1_hash';

const data: Data = {
  users: {},
};

function register(email: string, pw: string) {
  if (email in data.users) {
    return false;
  } else {
    data.users[email] = getHashOf(pw);
    return true;
  }
}

function login(email: string, pw: string) {
  if (email in data.users) {
    if (getHashOf(pw) === data.users[email]) {
      return true;
    }
  }
  return false;
}


9.1_auth_fixed.ts

type Data = {
  users: { [email: string]: string };
};

const data: Data = {
  users: {},
};

function register(email: string, pw: string) {
  if (email in data.users) {
    return false;
  } else {
    data.users[email] = pw;
    return true;
  }
}

function login(email: string, pw: string) {
  if (email in data.users) {
    if (pw === data.users[email]) {
      return true;
    }
  }
  return false;
}


9.1_auth_simple.ts

import crypto from 'crypto';

function getHashOf(plaintext: string) {
  return crypto.createHash('sha256').update(plaintext).digest('hex');
}

const msg = 'BigMacSecretSauce';
const hash = getHashOf(msg);

console.log(hash);

export { getHashOf }; // ignore this line
