lifeart

  hooks.afterEach(async function () {
    const base = this.owner['base'];
    /*
     * Reset container state to be able to run initializers again
     */
    base.willDestroy();
    base._booted = false;
    base._initializersRan = false;
    base._bootPromise = undefined;
    base._readinessDeferrals = 1;

lifeart

import Controller from '@ember/controller';
import { inject as service } from '@ember/service';
import { action, notifyPropertyChange, set, computed } from '@ember/object';


export default class ApplicationController extends Controller {
  appName = 'Ember Twiddle';
  @service state;
  
  @action update() {

lifeart

class ElasticHashMap<K, V> {
  private totalSize: number;                // total number of entries in the map
  private maxLoadFactor: number;           // load factor (e.g., 0.75 means 25% slack, δ = 0.25)
  private levels: { table: any[], size: number }[];  // sub-arrays for open addressing
  private salts: { base: number, step: number }[];   // random salts for hashing per level
  // Doubly-linked list for insertion order iteration:
  private head: { key: K, value: V, next: any, prev: any } | null;
  private tail: { key: K, value: V, next: any, prev: any } | null;
  // Tombstone marker for deleted slots:
  private static TOMBSTONE = Symbol("TOMBSTONE");

lifeart

Using a Proxy as the property descriptor itself in JavaScript allows you to intercept and customize how the engine interacts with the descriptor's attributes (like value, get, set, writable, etc.) during property definition. This approach provides dynamic control over the descriptor's behavior at the moment the property is defined. Here's how you can leverage this technique and its benefits:

---

Key Use Cases & Benefits

1. Dynamic Descriptor Attributes

Intercept access to descriptor properties (e.g., value, get, set) and compute them on-the-fly during property definition.

lifeart

declare namespace Telegram {
  interface EventHandlers {
    [eventType: string]: Function[];
  }

  interface InitParams {
    tgWebAppData?: string;
    tgWebAppThemeParams?: string;
    tgWebAppVersion?: string;
    tgWebAppPlatform?: string;

lifeart

// one of possible signals implementations

const USED_SIGNALS: Set<Signal> = new Set();
const RELATED_WATCHERS: WeakMap<Computed, Set<Watcher>> = new WeakMap();
const COMPUTED_SIGNALS: WeakMap<Signal, Set<Computed>> = new WeakMap();

class Signal {
  value: any;
  get() {
    USED_SIGNALS.add(this);

lifeart

// @ts-check
// https://codepen.io/lifeart/pen/abMzEZm?editors=0110
// https://github.com/glimmerjs/glimmer-vm/issues/1540

/*
  This is a proof of concept for a new approach to reactive programming.
  It's related to Glimmer-VM's `@tracked` system, but without invalidation step.
  We explicitly update DOM only when it's needed and only if tags are changed.
*/
let rowId = 1;

lifeart

var classes = {};
var cnt = 1;
function hashForClass(rawClassName) {
  const className = rawClassName.trim();
  if (className in classes) {
    classes[className].cnt++;

    return classes[className].index;
  } else {
    classes[className] = {

lifeart

class Bar {
    doSomething() {
        console.log('do something');
    }
    name: string;
}

type PromisifyProps<T> = {
    [P in keyof T]: T[P] extends (...args: infer A) => infer R ? (...args: A) => Promise<R> : Promise<T[P]>;
};

lifeart

type Square = {
  x: number;
  width: number;
}
const squares: Square[] = [
  {
    x: 0,
    width: 10,
  },
  {