Search

This val exports a utility function that returns a list of all a user's val, filtered by a callback function.

import { fetchPaginatedData } from "https://esm.town/v/nbbaier/fetchPaginatedData";

export async function filterVals(id: string, filter: (value: any, index: number, array: any[]) => unknown) {

const token = Deno.env.get("valtown");

const res = await fetchPaginatedData(`https://api.val.town/v1/users/${id}/vals`, {

import { email } from "https://esm.town/v/std/email?v=9";

function fetchRandomJoke() {

const response = fetch(

"https://official-joke-api.appspot.com/random_joke",

export default async function server(request: Request): Promise<Response> {

const html = `

let previousMousePosition = { x: 0, y: 0 };

function animate() {

requestAnimationFrame(animate);

window.addEventListener('resize', onWindowResize, false);

function onWindowResize() {

camera.aspect = window.innerWidth / window.innerHeight;

document.addEventListener('mouseup', onMouseUp, false);

function onMouseDown(event) {

isDragging = true;

y: event.clientY

function onMouseMove(event) {

if (!isDragging) return;

previousMousePosition = { x: event.clientX, y: event.clientY };

function onMouseUp(event) {

isDragging = false;

export function extractValInfo(url: string | URL) {

const { pathname, search } = new URL(url);

const [author, filename] = pathname.split("/").slice(-2);

import { fetchJSON } from "https://esm.town/v/stevekrouse/fetchJSON?v=45";

import { refs } from "https://esm.town/v/stevekrouse/refs?v=11";

type CronFunction = (interval: Interval) => Promise<void>;

export const cronEvalLogger = (cron: CronFunction): CronFunction => {

let interval: Interval;

const cronProxy = new Proxy(cron, {

The following is an example of wrapping the use of an API in a small backend function. This pattern is useful for preparing data before using in Framer, and is used in the Fetch tutorial video. It follows the pattern of calling a source API, parsing the data, setting up the CORS headers, and then responding with data.

export default async function(req: Request) {

const data = await fetch("https://api.fetch.tools/status");

const status = await data.json();

const stream = test.createStream({ objectMode: true });

stream.on("data", function(row) {

console.log(JSON.stringify(row));

test("timing test", function(t) {

t.plan(2);

t.equal(typeof Date.now, "function");

var start = Date.now();

setTimeout(function() {

t.equal(Date.now() - start, 100);

export const testing = new Promise(resolve => {

stream.on("end", function(row) {

resolve("ok");

import { email } from "https://esm.town/v/std/email?v=9";

async function fetchRandomJoke() {

const response = await fetch(

"https://official-joke-api.appspot.com/random_joke",

export default async function handler(req) {

try {

const result = await (async () => {

function isPrime(num) {

if (num <= 1) return false;

return true;

function findLowestThreeDigitPrime() {

for (let num = 100; num < 1000; num++) {

function extractToken(authorization: string) {

const parts = authorization.split(" ");

if (parts[0] != "Bearer") {

return null;

return parts[1];

export function bearerAuth(next: (req: Request) => Response | Promise<Response>, params: {

verifyToken: (password: string) => boolean | Promise<boolean>;

return async (req: Request) => {

import { email } from "https://esm.town/v/std/email?v=9";

function fetchRandomJoke() {

const SAMPLE_JOKE = {

"setup": "What do you call a group of disorganized cats?",

subject: setup,

async function fetchRandomJoke() {

const response = await fetch(

"https://official-joke-api.appspot.com/random_joke",

export type Action = z.infer<typeof Action>;

export function get(state: State, col: number, row: number): Slot {

return state.board[col][row];

export function set(state: State, col: number, row: number, slot: Slot): void {

state.board[col][row] = slot;

| "column_out_of_bounds";

export function check_action(state: State, action: Action): ActionCheck {

if (action.player !== state.next_player) {

return "ok";

function check_slots_eq(a: Slot, b: Slot, c: Slot, d: Slot): Slot {

if (a === b && b === c && c === d) {

return null;

export function status(state: State): Status {

// Check Vertical Win

return { status: "over", result: { kind: "draw" } };

export function apply_action(state: State, action: Action): Status {

// Action should be checked before calling this function.

// We assert that the action is ok.

export function moveHead(head, dir) {

if (["RIGHT", "LEFT"].includes(dir)) {

return {

export async function web_YhrAkPFife(req) {

return new Response(`<!DOCTYPE html>

<html>

import { renderToString } from "npm:react-dom/server";

export default async function(req: Request): Promise<Response> {

return new Response(

renderToString(

<textarea id="editorSource" className="for-codemirror" name="editorSource">

{`let hasAnError: string = 10;

function increment(num: number) {

return num + 1;

increment('not a number');`}