devinrhode2

/**
 * Calls `callback`, catches any errors and returns `returnValue | Error`
 *
 * TODO: create npm package
 *
 * See: https://dev.to/devinrhode2/comment/1fcga
 */
export const safeCall = <
  TCallback extends (
    ...args: unknown[]

devinrhode2

import { execaCommandSync } from 'execa'

/** @type {(cmdString: string, debug?: 'debug') => [string | undefined, string | unknown]} */
export const exec = (cmdString, debug) => {
  let exception
  let result
  try {
    result = execaCommandSync(cmdString, {
      env: {
        // @ts-expect-error - not application code

rwjblue

import Ember from 'ember';

export default Ember.Controller.extend({
  numbers:['1','2','3','4'],
  letters:['a','b','c','d']
});

RSNara

function memoize(object, name, descriptor) {
  var fn = descriptor.value;
  var memoized = function() {
    memoized.cache = memoized.cache || {};
    var key = JSON.stringify(arguments);
    return memoized.cache[key] = memoized.cache[key] 
      ? memoized.cache[key]
      : fn.apply(this, arguments);
  } 
  descriptor.value = memoized;

devinrhode2

warn on empty jquery selection

Graduated to github: https://github.com/devinrhode2/StrictjQuery.js

But for the simple version (quite possibly better): (wait no its broke use the one on GH)

Warns when you have an empty jQuery selection, unless you do $('foo', failsafe);

 $.badSelectorAction = function badSelectorActionFn( selector, context ) {

Raynos

Why the jQuery Abstraction isn't needed.

(One needs some form of browser normalization so that modern features works, no-one is doubting that).

Related: [jQuery library critique][2]

Abstractions that aren't needed

Selectors

devinrhode2

function postTweet(tweet /*string*/, from /*string*/) {
  typeCheck(arguments);
}
postTweet('string', 'asdf');
postTweet('string', 222); //TypeError! run in console to see a nice error message!

function typeCheck(a) {
  var newArr = [].slice.call(a);
  var types = [];
  var f = a.callee.toString();

mediaupstream

// It's composable

const compose = (a,b) => v => a(b(v))
const isValid = valid => fn => (...p) => valid(...p) && fn(...p)

const hasTwoParams = isValid((...params) => params.length === 2)
const firstParamIsArray = isValid(a => Array.isArray(a))
const hasTwoFirstArray = compose(hasTwoParams, firstParamIsArray)
const myValidatedFn = hasTwoFirstArray((a, b) => console.log('It worked', a, b))

chriseppstein

An example of a simple form

Consider the following markup:

<form class="root" state:theme=dark state:compact>
  <div class="input-area">
    <label for="username" class="label">Username:</label>
    <input id="username" class="input" type="text">
  </div>

wycats

A small sampling of external projects initially built for Ember use but designed to be used standalone:

• Handlebars - templating engine
• simple-html-tokenizer - an HTML5 tokenizer
• HTMLBars - alternate HTML-aware Handlebars backend
• morph - text-node placeholders for data binding systems
• RSVP - fast, lightweight promise library
• route-recognizer - just the recognition part of a router
• router.js - hierarchical states and transition-based router
• dag-map - graph library