okikio

import type { Logger as LogTapeLogger } from "@logtape/logtape";

import { deepMerge } from "@bundle/utils/utils/deep-equal.ts";
import { getLogger } from "@logtape/logtape";

export const initLogger = getLogger(["@bundle/core", "init"]);
export const buildLogger = getLogger(["@bundle/core", "build"]);
export const generalLogger = getLogger(["@bundle/core", "general"]);
// Add more loggers as needed

okikio

import type { Filter } from "./filter.ts";
import type { LogLevel } from "./level.ts";
import type { LogRecord } from "./record.ts";
import type { Sink } from "./sink.ts";

/**
 * A logger interface.  It provides methods to log messages at different
 * severity levels.
 *
 * ```typescript

okikio

Specification for TypeScript Import and Export Notation

Overview

This specification defines a notation format for representing TypeScript imports and exports. It is designed to be concise, flexible, and easily understandable, suitable for use in various contexts including configuration files, command-line interfaces, and documentation.

Format Design

Basic Structure

• Imports and Exports: Use - to start import declarations and ~ to start export declarations.
• Namespace Imports: Double bangs !! indicate namespace imports (e.g., * as name).

okikio

// Based off of https://github.com/esbuild/esbuild.github.io/blob/main/src/try/fs.ts 
// GitHub Permalink: https://github.com/esbuild/esbuild.github.io/blob/d405aa5f06ef359430344ca7fcbbc9bc8acf620e/src/try/fs.ts

// This file contains a hack to get the "esbuild-wasm" package to run in the
// browser with file system support. Although there is no API for this, it
// can be made to work anyway by pretending that node's "fs" API is present.
import { decode, encode } from "./encode-decode";

const enum Kind {
  File,

okikio

export class Component {
  /** 
   * For perf. reasons use a class to delagate event handlers,
   * this lets us avoid binds and arrow functions which have memory overhead, 
   * in addition since it's always the same instance of the same class,
   * so it's super easy to remove later on
   * 
   * Based on https://webreflection.medium.com/dom-handleevent-a-cross-platform-standard-since-year-2000-5bf17287fd38
   */
  static #eventhandlers = new WeakMap();

okikio

import { CLIENT_ID, CLIENT_SECRET } from "~/env.ts";
import { gmail_v1, auth } from "@googleapis/gmail";
import { Hono } from '@kyiro/hono';
import open from 'open';

const REDIRECT_URI = "http://localhost:8000/token";
const SCOPE = "https://www.googleapis.com/auth/gmail.readonly";

console.log({
  SCOPE,

okikio

Unified URI Spec. Brainstorm

Hey 👋, I was working on the proposals for unifying the URL specs. From the research I’ve done on the topic so far, we’d need a total of 2 RFC's to solve to problem and ensure it never occurs again.

Unified URI RFC (RFC 1)

The 1st RFC (The Unified URI RFC) will use the original 2005 URI RFC as it’s basis, then build on top of it the modern WHATWG URL standard. Alwin Blok already created a new URL Spec. proposal to try to accomplish this very goal, we’ll investigate what changes there are between both RFC’s and the new proposal by Alwin, and look to create a Unified RFC from that.

Some ideas that @Randall, Jonathan Neal, and I played with were separating URI’s and URL’s.

• URI’s represent any form a path locator ca

okikio

import * as ts from "https://esm.sh/typescript"

/**
 * Determines whether escape sequences in a token of a specific kind should be preserved.
 * Useful for maintaining the integrity of literals where escape characters are meaningful.
 *
 * @example
 * // Simple: In string literals like `"Hello\nWorld"`, the `\n` should be preserved.
 * shouldPreserveEscapes(ts.SyntaxKind.StringLiteral);
 * 

okikio

import { signal, effect } from 'https://esm.sh/usignal';

// Function to check if an expression is iterable
function isIterable(expression) {
  return Symbol.iterator in Object(expression);
}

// Function to create a new DOM range for an expression
function createDOMRange(domElement, expression) {
  const textNode = document.createTextNode(evaluateExpression(expression.expr));

okikio

const isWorker = typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope;

async function getHandleFromPath(path: string) {
  const pathParts = path.split('/').filter(part => part.length > 0);
  let currentHandle = await navigator.storage.getDirectory();

  for (const part of pathParts) {
    if (part === '..') {
      currentHandle = await currentHandle.getParent();
    } else {