Basarat Ali Syed basarat

Notice that we’ve been using the term, fulfilled instead of resolved, and the reason is that a promise can be resolved to another promise and which point its fate becomes dependent on the other promise. If the other promise gets fulfilled our promise gets fulfilled, if the other promise is rejected, our promise gets rejected.

Both alpha and beta are resolved, but they settle to different fates. Alpha gets fulfilled, Beta gets rejected.

const delayFulfill =
  () => new Promise(
    res => setTimeout(() => res('fulfilled'), 1000)
 );

	import { add } from 'date-fns';

	/** Add one day to a given input */
	function tomorrow(date: Date) {
	return add(date, { days: 1 });
	}

	const now = new Date('2022-04-03 00:00:00');
	const next = tomorrow(now);
	console.log(now.toLocaleString(), '--', next.toLocaleString());

	MIT License

	Copyright (c) 2020 Basarat Ali Syed

	Permission is hereby granted, free of charge, to any person obtaining a copy
	of this software and associated documentation files (the "Software"), to deal
	in the Software without restriction, including without limitation the rights
	to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	copies of the Software, and to permit persons to whom the Software is
	furnished to do so, subject to the following conditions:

	export type Class = new (...args: any[]) => any;

	export function DisposableMixin<Base extends Class>(base: Base) {
	return class extends base {
	isDisposed: boolean = false;
	dispose() {
	this.isDisposed = true;
	}
	};
	}

	// create react app
	npx create-react-app my-app --template typescript
	cd my-react-app


	// install
	npm i cypress cypress-react-unit-test

	// tsconfig.json
	"types": [

	export function App() {

	const counterOne = useCounter();
	const counterTwo = useCounter();

	return (
	<div>
	<Counter use={counterOne}/>
	<Counter use={counterTwo}/>

	type DeepReadonly<T> = {
	readonly [P in keyof T]
	: DeepReadonly<T[P]>;
	}

	function Counter() {
	// Some hooks the component needs
	const [count, setCount] = useState(0);

	// The rendering of the component
	return (
	<div>
	<p>You clicked {count} times</p>
	<button onClick={() => setCount(count + 1)}>
	Click me

	import { Validator, applyValidators } from 'formstate';

	/** One of the easy to validate values */
	export type SimpleValue = string \| boolean \| number \| null \| undefined;

	/**
	* - Whitespace strings / false / null / undefined are considered invalid
	*/
	export const required: Validator<SimpleValue> = (value) => {
	const error = "Value Required";

	import App from 'next/app'
	import { setStylesTarget } from 'typestyle'

	export default class MyApp extends App {
	componentDidMount() {
	/**
	* Hydrate typestyle
	*/
	setStylesTarget(document.getElementById('styles-target')!)
	}