Jaime Sangcap jaimesangcap

Using JavaScript Libraries from ClojureScript

Using JavaScript libraries from ClojureScript involves two distinct concerns:

Packaging the code and delivering it to the browser
Making ClojureScript code that accesses JavaScript libraries safe for advanced optimization

Right now, the only single tool that solves these probems reliably, optimally, and with minimal configuration is shadow-cljs, and so that is what I favor. In paricular, shadow-cljs lets you install npm modules using npm or yarn and uses the resulting package.json to bundle external dependencies. Below I describe why, what alternatives there are, and what solutions I disfavor at this time.

Packaging and Delivering Code

Alex Miller's new add-lib capability, hacked into ClojureScript:

deps.edn:

{:deps {org.clojure/clojurescript {:git/url "https://github.com/mfikes/clojurescript"
                                   :sha "4fa9edd736d47b8ef5648b61b199e64ef80735bb"}
        org.clojure/tools.deps.alpha {:git/url "https://github.com/clojure/tools.deps.alpha.git"
                                      :sha "d492e97259c013ba401c5238842cd3445839d020"}}}

Office Web Apps Viewer

('.ppt' '.pptx' '.doc', '.docx', '.xls', '.xlsx')

http://view.officeapps.live.com/op/view.aspx?src=[OFFICE_FILE_URL]

<iframe src='https://view.officeapps.live.com/op/embed.aspx?src=[OFFICE_FILE_URL]' width='px' height='px' frameborder='0'>
</iframe>

OneDrive Embed Links

ClojureScript macros: kinda, sorta, not really.

ClojureScript does not have a standalone macro system. To write ClojureScript macros, one must write them in Clojure and then refer to them in ClojureScript code. This situation is workable, but at a minimum it forces one to keep ClojureScript code and the macros it invokes in separate files. I miss the locality of regular Clojure macros, so I wrote something called maptemplate that gives me back some of what I miss. The technique may be useful in other scenarios.

Problem

Suppose you're wrapping functionality in another namespace or package so that you can have your own namespace of identically named but otherwise decorated functions:

ClojureScript:

Clojure Destructuring Tutorial and Cheat Sheet

(Related blog post)

Simply put, destructuring in Clojure is a way extract values from a datastructure and bind them to symbols, without having to explicitly traverse the datstructure. It allows for elegant and concise Clojure code.

	// Let's say you have a function that does some async operation inside setTimeout (think of polling for data)

	function runInterval(callback, interval = 1000) {
	setInterval(async () => {
	const results = await Promise.resolve(42) // this might fetch some data from server
	callback(results)
	}, interval)
	}

	// Goal: We want to test that function - make sure our callback was called

	(ns api-project.cors)

	(def cors-headers
	"Generic CORS headers"
	{"Access-Control-Allow-Origin" "*"
	"Access-Control-Allow-Headers" "*"
	"Access-Control-Allow-Methods" "GET"})

	(defn preflight?
	"Returns true if the request is a preflight request"

	(ns demo.core-test
	(:require [cljs.test :refer [deftest
	testing
	is
	use-fixtures]]
	[clojure.string :refer [lower-case]]
	[demo.components :refer [title-component
	counter-component]]
	[reagent.core :as r]
	["react-testing-library" :as rtl]))

	//Create Private Key with OpenSSL
	//openssl genpkey -algorithm RSA -pkeyopt rsa_keygen_bits:4096 -pkeyopt rsa_keygen_pubexp:3 -out privateKey.pem
	//Generate Public Key to be used at the client side (Mobile)
	//openssl pkey -in privateKey.pem -out publicKey.pem -pubout
	const crypto = require('crypto')
	const fs = require('fs')

	const private_key = fs.readFileSync('digital_sign/privateKey.pem', 'utf-8')
	//File to be signed
	const package = fs.readFileSync('webpackage.zip')

	<!DOCTYPE HTML>
	<html lang="en-US">
	<head>
	<meta charset="UTF-8">
	<title>test upload by chunk</title>
	</head>
	<body>
	<input type="file" id="f" />

	<script src="script.js"></script>