gatsbyjs-employees

To the Gatsby Community,

We want to start by specifically thanking Nat Alison. We support her and commend her bravery in speaking out. It is not easy to stand alone. What she experienced at Gatsby was unacceptable and speaks to wider issues. We thank her for putting pressure on the company to fix them. We vow to double down on those efforts.

While we have worked hard to give feedback and help create a healthy work environment over the past few years, change has been far too slow and the consequences have been real. The previous weeks have intensified the need for rapid change by increasing employee communication and allowing us to collectively connect some dots. We are just as outraged. As a result, we have posed a series of hard questions to management as well as a list of concrete actions they need to take.

Kyle Mathews' public apologies to both Nat Alison and Kim Crayton are small actions swiftly taken that signal the possibility for change but don't speak to the systemic issues that must be addressed.

aleclarson

It's 2024. You should use tsup instead of this.

---

Features

🔥 Blazing fast builds
😇 CommonJS bundle
🌲 .mjs bundle
✨ .d.ts bundle + type-checking

mattpocock

Intro

Static analysis of state machines has enormous potential. In this RFC, I'd like to talk about using a CLI tool to generate perfect Typescript types by analysing XState machines in your code.

Typescript with XState is currently imperfect because of XState's innate complexity. The goal is to:

1. Get perfect typing of any MachineOptions types passed into Machine, interpret, useMachine etc. This includes typings of events, services, actions, guards and activities based on their usage in the machine.
2. Get autocomplete on the matches function in interpreted state nodes, to allow state.matches('even.deep.nested.states') to be type-checkable.

This CLI could, in the future, be tooled to achieve some other stretch goals:

mattpocock

import { useMachine } from '@xstate/react';
import {
  StateMachine,
  AnyEventObject,
  EventObject,
  State,
  Interpreter,
  ActionObject,
  ActionFunction,
} from 'xstate';

rauschma

/* 
Proof of concept: Writing dual-mode (sync and async) code via generators

Recommendation: start by reading the example (at the end).

API:
– The API object is called `def`.
– Dual-mode `await`: const unwrapped = yield wrapped;
– Dual-mode `yield`: yield def.$one(singleValue)
– Dual-mode `yield*`: yield def.$all(iterable)

alexreardon

import React, { createContext, ReactNode, useEffect, useMemo, useRef, useState } from 'react';
import { interpret } from 'xstate';
import useRequiredContext from '../shared/use-required-context';
import { Nullable } from '../types';
import isShallowEqual from './is-shallow-equal';
import machine from './machine';
import { MachineEvents, MachineStateType, ServiceType } from './machine-types';

const ServiceContext = createContext<Nullable<ServiceType>>(null);

mergesort

import SwiftUI

let colors = [
    Color.pink,
    Color.blue,
    Color.green,
    Color.orange,
    Color.purple,
    Color.black,
]

ggoodman

{
  "PendingSocket": {
    "kind": "Intermediate",
    "onEnter": [
      {}
    ],
    "onEvent": {
      "Error": [
        {
          "targetStates": [

AleksejDix

<template>
  <Machine :machine="machine">
    <template #default="{current, send}">
      <div
        id="box"
        :style="{
          '--dx': current.context.dx,
          '--dy': current.context.dy,
          '--x': current.context.x,
          '--y': current.context.y

busypeoples

/**
 * TS Helper Functions
 */
type ConvertTo<Type, From, To> = {
  [Key in keyof Type]: Required<Type>[Key] extends From ? To : Type[Key];
};

type FilterByType<T, U> = {
  [Key in keyof Required<T>]: Required<T>[Key] extends U ? Key : never;
}[keyof T];