genki

import type {Plugin} from 'vite';
import path from 'path';
import fs from 'fs';

const publicDir = path.resolve(__dirname, '../../public');
const distDir = path.resolve(__dirname, '../../dist');

const copyMtime = (srcDir:string, dstDir:string):void => {
    console.log('keep-mtime: copying stat', srcDir, '->', dstDir);
  for (const file of fs.readdirSync(srcDir)) {

genki

#!/usr/bin/env ruby
# ./distの中身を./dist.dataにまとめる
DIST_DIR = './dist'
OUT_PATH = "./dist.data"

paths = []
Dir["#{DIST_DIR}/**/*"].each do |path|
  next if File.directory?(path)
  pathO = path.gsub("#{DIST_DIR}", '')
  paths << [path, pathO]

genki

const translator = <Result extends string|Promise<string>>() => {
  type A = any[];
  function t(s?:TranslateOptions):
    (s:TemplateStringsArray, ...values:A) => Result;
  function t(s:string,...values:A):(s:string, ...values:A) => Result;
  function t(n:number|Signal<number>, s?:TranslateOptions):
    (s:TemplateStringsArray, ...values:A) => Result;
  function t(n:number|Signal<number>, s?:TranslateOptions):
    (s:string, ...values:A) => Result;
  function t(s:TemplateStringsArray, ...values:A):Result;

genki

#!/usr/bin/env ruby
# A simple preprocessor for terraform.
#
# USAGE:
#
#   invade <template dir> <modules dir>
#
# This script will copy all tf files in the template dir to the modules dir
# and replace the `//invade <invader name> <args>` with the content of the
# invader file located at `./invader/<invader name>.tf`.

genki

const Flag = {
  foo: 1,
  bar: 2,
  baz: 4,
} as const;

type MaskType = MaskOf<typeof Flag[keyof typeof Flag]>;
//   ^? 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7

type SparseMaskType = MaskOf<1|2|8>;

genki

// pack bytes into valid UTF-16 string
//
// strategy:
//
// * using ESC as the escape character
//  * if there is ESC in the bytes, double it
// * if there is unmatched surrogate pair, mark it by the escape character
//
// 0x007f: escape, because it's rare but still only one utf-8 byte.
//   To escape itself, use 0x007f 0x08ff (two bytes utf-8)

genki

const outof = <T extends BaseSchema, R,
  O = T extends BaseSchema<any, infer O> ? O : never,
>(schema:T, value:unknown, then?:(value:O) => R): value is O => {
  const {issues, output} = safeParse(schema, value);
  if (issues && issues.length > 0) return false;
  if (then) then(output as O);
  return true;
};

// USAGE example

genki

export const waiter: {
  <T, R, A extends any[]>(
    w:Waitable<T>, done:(x:T, ...args:A) => Promise<R>|R
  ): (...args:A) => Promise<R>;
  <R, A extends any[], T=void|undefined>(
    w:Waitable<T>, done:(...args:A) => Promise<R>|R
  ): (...args:A) => Promise<R>;
} = <T, R, A extends any[]>(w:Waitable<T>, done:{
  (x:T, ...args:A):Promise<R>|R;
  (...args:A):Promise<R>|R;

genki

import type {
  FormStore, FieldValues, ResponseData, FormErrors, FieldPath, FieldArrayPath,
  SetResponseOptions,
} from '@modular-forms/qwik';
import {
  getValues, validate, setResponse, FormError, setError,
} from '@modular-forms/qwik';
import { type Maybe } from '~/utils';

type ErrorResponseOptions = SetResponseOptions &

genki

#!/usr/bin/ruby
opts, files = ARGV.partition {|a| a =~ /^-/}
first, *middle, last = files
base = File.expand_path File.dirname(first)
to = File.expand_path File.join base, last
system ['mv', *opts, first, *middle, to].join ' '