Joseph Lawson joekiller

Most Cursive IDE nREPL solutions point to the Figwheel approach which good but is a little cumbersome.

You can also use piggieback (which Figwheel also uses).

Update your project.clj as such:

(defproject blah "0.0.1"
  :profiles {:dev {:dependencies [[com.cemerick/piggieback "0.2.2"]]}
                   :repl-options {:nrepl-middleware [cemerick.piggieback/wrap-cljs-repl]}})

via Sangria Craft hat sku list https://pastebin.com/raw/qTc9Xd9Y

Updates

=======

6/16/2023

added

The Pocket Raiders
Tartan Tyrolean

	-- Setup an AWS Athena Application Load Balancer table via
	-- http://docs.aws.amazon.com/athena/latest/ug/application-load-balancer-logs.html
	-- Use the following to query between timestamps.
	SELECT * FROM "sampledb"."alb_logs"
	where date_parse(time, '%Y-%m-%dT%H:%i:%s.%fZ')
	between TIMESTAMP'2017-12-20 03:00:00' and TIMESTAMP'2017-12-20 05:00:00'
	limit 10;

	for p in $(aws iam list-policies --query 'Policies[?starts_with(PolicyName, `start-pipeline`) == `true`].Arn' --output text); do
	for v in $(aws iam list-policy-versions --policy-arn $p --query 'Versions[?IsDefaultVersion == `false`].VersionId' --output text); do
	aws iam delete-policy-version --policy-arn $p --version-id $v
	done
	aws iam delete-policy --policy-arn $p
	done

	import yaml
	from aws_cdk import core

	class RawStack(core.Stack):
	def __init__(self, scope: core.Construct, name: str, template_path: str, wrapped_parameters=None,
	**kwargs) -> None:
	"""import a stack off a path and munge in ssm variables if desired

	:param template_path: path to raw stack being imported
	:param wrapped_parameters: map of Parameter keys and default values

	import codepipeline = require('@aws-cdk/aws-codepipeline');
	import iam = require('@aws-cdk/aws-iam');
	import cdk = require('@aws-cdk/core');
	import { ActionCategory } from '@aws-cdk/aws-codepipeline';
	import { Action } from '@aws-cdk/aws-codepipeline-actions';

	/**
	* The OS and type of application you are testing.
	*/
	export enum DeviceFarmAppType {

	const data: string = await new Promise((resolve, reject) => {
	https.get(targetUrl, (res) => {
	res.setEncoding('utf8');
	let rawData = '';
	res.on('data', (chunk) => {
	rawData += chunk;
	});
	res.on('end', () => {
	try {
	resolve(rawData);

	declare module 'pushbullet' {
	import { EventEmitter } from 'events';
	import { Response } from 'node-fetch';

	interface MakeRequestOptions<T> {
	qs?: Record<string, string>
	json?: T
	}

	export interface MeResponse {

	import https from "https";

	export async function httpsPost<T>(params: { hostname: string, path: string, headers: Record<string, any>, body?: string }): Promise<{ status: number, data: T \| string }> {
	let {path, hostname, body, headers} = params;
	let options = {
	hostname,
	port: 443,
	path,
	method: 'POST',
	headers

	import ReconnectingWebSocket from 'reconnecting-websocket';
	import WS from 'ws';
	import * as Events from 'reconnecting-websocket/events';

	export default class BackpackSocketManager {
	private ws: ReconnectingWebSocket;

	constructor() {
	this.ws = new ReconnectingWebSocket('wss://ws.backpack.tf/events', [], {
	WebSocket: WS,