3f:null 40:["$","title",null,{"children":"prommy | Riley | Observable"}] 46:T455,{ prommy; // artificially make crypto.subtle into a promise, for demonstration let crypto = Promises.delay(1, globalThis.crypto.subtle); let keys, encoded; let raw = !this ? "crypto test" : [...this].map(c => String.fromCodePoint(c.codePointAt() + 1)).join(""); // effectively call crypto.subtle.generateKey({…}, true, ["encrypt", "decrypt"]) keys = crypto .call("generateKey", { name: "RSA-OAEP", modulusLength: 4096, publicExponent: new Uint8Array([0x01, 0x00, 0x01]), hash: "SHA-512" }, true, ["encrypt", "decrypt"] ); yield crypto .call({f: "encrypt", await: true}, keys.get("publicKey", "algorithm"), keys.get`publicKey`, encode(raw) ) .do(function() { encoded = this; }) .then(decode); await Promises.delay(2000); yield crypto .call("decrypt", await keys.get("privateKey", "algorithm"), await keys.get`privateKey`, await encoded) .then(decode); return keys; function encode(text) { return new TextEncoder().encode(text); } function decode(text) { return new TextDecoder().decode(text); } }47:Tbce,

`${Promise.prototype.call.name}` 🏷️

.${Promise.prototype.call.name}(f, …arguments)
.${Promise.prototype.call.name}({f, this, await}, …arguments)

similar construct

.${Promise.prototype.then.name}(f == null
${"\t"}? input => input(…arguments)
${"\t"}: input => input[f](…arguments)
)

This calls a function and returns its value in the form of a new promise. The function to be called is defined by f.

f is a function: f is the function.
f is nullish: input is treated as the function.
f is neither: The property f of input is treated as the function.

Specifying an options object as the first argument to ${Promise.prototype.call.name} allows you to adjust behavior.

f: This is nullish by default and represents f, the function to be called.
this: This is the value of this to supply to the function. If this is missing or undefined, then it defaults to input.
await: Setting this to truthy enables awaiting on arguments before passing them into f.

If a non-function is found where a function is expected, a ${TypeError.name} is thrown.

.${Promise.prototype.call.name}`name`

similar construct

.${Promise.prototype.then.name}(input => input[name]())

The entire contents of the template literal are interpreted as a property key (either a single symbol or a concatenated string). Then, ${Promise.prototype.call.name} is called recursively, with this property key as name, with undefined as this, and with no arguments.

`${Promise.prototype.do.name}` 🏷️

This behaves identically to call, except input is preserved. The returned promise resolves to the same value, unless the provided function throws.

48:T867,

`${Promise.prototype.check.name}` 🏷️

.${Promise.prototype.check.name}(func)

similar construct

.${Promise.prototype.then.name}(input => {
${"\t"}if (!["", undefined, null].includes(func(input))) {
${"\t\t"}throw func(input);
${"\t"}}
${"\t"}return input;
})

func must be a function that accepts input as its only argument. It is called with its ‘this’ as input, and it may throw or return. A new promise is returned that rejects when func throws or returns a value that is not nullish or the empty string. If func returns a promise, then that value is awaited for.

.${Promise.prototype.check.name}`name`

similar construct

.${Promise.prototype.then.name}(input => {
${"\t"}if (!input[name]) {
${"\t\t"}throw new ${TypeError.name}();
${"\t"}}
${"\t"}return input;
})

The entire contents of the template literal are interpreted as a property key (either a single symbol or a concatenated string). Then, ${Promise.prototype.check.name} is called recursively, providing a function that checks whether accessing this property key on input yields a truthy value; if not, a ${TypeError.name} is thrown.

49:T7ef,

`${Promise.prototype.get.name}` 🏷️

.${Promise.prototype.get.name}(…props)

similar construct

.${Promise.prototype.then.name}(input => { switch(props.length) {
${"\t"}case 1: return input[props[0]];
${"\t"}case 2: return input[props[0]][props[1]];
${"\t"}// …
}})

This is a simple accessor. Each property key in props causes the accessor to dig one level deeper into input’s properties. There must be at least one property key supplied.

.${Promise.prototype.get.name}`name`

similar construct

.${Promise.prototype.then.name}(input => input[name])

The entire contents of the template literal are interpreted as a property key (either a single symbol or a concatenated string). The returned promise accesses this property from input.

`${Promise.prototype.getSafe.name}` 🏷️

This behaves similarly to ${Promise.prototype.get.name}, except whenever it encounters a nullish value, that value is returned instead of trying to get properties of null or undefined. This avoids throwing ${TypeError.name}s.

4a:Tbe8,prommy = Object.defineProperties(Promise.prototype, Object.fromEntries(Object.entries({ get(...props) { if (!props.length) { throw new TypeError("no property name provided"); } if (parseTag.check(props[0])) { props = parseTag(...props); return this.then(x => x[props]); } return this.then(async x => { for (let p of props) { x = await x[p]; } return x; }); }, getSafe(...props) { if (!props.length) { throw new TypeError("no property name provided"); } if (parseTag.check(props[0])) { props = parseTag(...props); return this.then(x => x == null ? x : x[props]); } return this.then(async x => { for (let p of props) { if (x == null) { return x; } x = await x[p]; } return x; }); }, call(cfg = {}, ...args) { if (parseTag.check(cfg)) { return this.call(parseTag(...arguments)); } let f, thisValue, awaitArgs; if (primType(cfg) === "object") { f = cfg.f; thisValue = cfg.this; awaitArgs = cfg.await; } else { f = cfg; cfg = {f}; } awaitArgs && (args = Promise.all(args)); return this.then(f == null ? async x => Function.prototype.call.call(x, thisValue === undefined ? x : thisValue, ...await args) : typeof f === "function" ? async x => Function.prototype.call.call(f, thisValue === undefined ? x : thisValue, ...await args) : async x => { if (typeof x[f] === "function") { return Function.prototype.call.call(x[f], thisValue === undefined ? x : thisValue, ...await args); } throw new TypeError(`Property ${Object(f) instanceof Symbol ? String(x) : JSON.stringify(String(x))} is not a function; its type is ${typeof x[f]}.`); } ); }, do(...args) { return this.call(...args).then(() => this); }, check(func) { if (parseTag.check(func)) { func = parseTag(...arguments); let propTxt = typeof func === "symbol" ? func.toString() : JSON.stringify(func); return this.check(x => { if (!x[func]) { return new TypeError(`Property ${propTxt} is ${(func in x) ? "absent" : "falsy"}.`); } }); } if (typeof func !== "function") { throw new TypeError(`function expected instead of ${typeof func}`); } return this.then(async x => { let v = await Function.prototype.call.call(func, x, x); if (v != null && v !== "") { throw v; } return x; }); }, settled: { get() { return this.then(value => ({status: "fulfilled", value}), reason => ({status: "rejected", reason})); } } }).map(([name, value]) => [name, (value !== null && typeof value === "object" && Object.prototype === Object.getPrototypeOf(value)) ? Object.assign(("get" in value || "set" in value) ? {enumerable: true, configurable: true} : {enumerable: true, configurable: true, writable: true}, value) : {enumerable: true, configurable: true, writable: true, value} ]))) && Promise;4b:T846,4c:[] 44:{"id":"b4acf408ec0209a9","slug":"prommy","title":"prommy","thumbnail":"f1d39cbc7e4147db7cc6ee69597689ce8e8b7b9dcad6a8cf316c6e85835e0a59","access_level":"public","create_time":"$D2023-04-25T18:01:07.432Z","update_time":"$D2023-04-26T07:38:23.003Z","view_time":null,"first_public_time":"$D2023-04-25T18:01:07.432Z","has_unpublished_edits":null,"fork":false,"stars":0,"starred":false,"owner":{"type":"team","id":"d2b7afa3a61febdf","login":"rmw4269","name":"Riley","avatar_url":"https://avatars-next.observableusercontent.com/839ad38e4ca0e32eaad7be29b5bc0c3a7f4304d5f91dd0f3642acf08015b6530","tier":"starter_2024","bio":"I enjoy spreadsheets and JavaScript way too much.","following":false},"version":377,"publish_version":null,"role":null,"authored":false,"authors":[{"type":"individual","id":"817e538440b46e8a","login":"rmw4269","name":"Riley","avatar_url":"https://avatars-next.observableusercontent.com/839ad38e4ca0e32eaad7be29b5bc0c3a7f4304d5f91dd0f3642acf08015b6530","tier":null,"bio":"I enjoy spreadsheets and JavaScript way too much.\n\ntrust://Riley.science!","following":false}],"members":[{"type":"individual","id":"817e538440b46e8a","login":"rmw4269","name":"Riley","avatar_url":"https://avatars-next.observableusercontent.com/839ad38e4ca0e32eaad7be29b5bc0c3a7f4304d5f91dd0f3642acf08015b6530","tier":null,"role":"editor"}],"comments":[],"custom_thumbnail":false,"trashed":false,"lapsed":null,"subscribed":null,"forks":0,"collection":null,"type":"notebook","body":{"titling":"auto","title":"prommy","cells":[{"id":0,"value":"# prommy\n\nThis is a library that adds to promises several instance methods for various common constructs, making them a bit more convenient to use and easy to read.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"","database":"$undefined"},{"id":223,"value":"## examples","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"","database":"$undefined"},{"id":25,"value":"prommy &&\nfetch(\"//unpkg.com/d3/?meta\")\n .check(({ok, status, statusText}) => !ok ? \"\" : new Error(`HTTP ${status}: ${statusText}`))\n // throw for non-okay HTTP status\n .call`json` // call .json() on the response\n .settled // return a result as in Promise.allSettled","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":321,"value":"$46","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":129,"value":"

usage

In these descriptions, input refers to the fulfilled value of this promise instance. A nullish value is one that is strictly equal to null or undefined. Unless stated otherwise, all of the functions return new promises. All of this code is compatible with using symbols as property keys. Functions marked with “🏷️” have specific behavior when called as tagged template literals.

import {prommy} from \"@rmw4269/prommy\"

`settled`

.settled

similar construct

.${Promise.prototype.then.name}(\n${\"\\t\"}input => ({status: \"fulfilled\", value: input}),\n${\"\\t\"}reason => ({status: \"rejected\", reason})\n)

This acessor property returns a promise that resolves to values as if output from ${Promise.name}.${Promise.allSettled.name}. It will never reject.

","pinned":false,"hidden":false,"mode":"html","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"","database":"$undefined"},{"id":6,"value":"$4a","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":197,"value":"## appendix","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"","database":"$undefined"},{"id":21,"value":"parseTag = Object.assign(function parseTag(strs, ...vals) {\n let o = strs[0] ? [strs[0]] : [];\n let sym = false;\n for (let [i, v] of vals.entries()) {\n let s;\n if (v === null) {\n o.push(\"null\");\n } else if (typeof v === \"symbol\" || (typeof v === \"object\" && v instanceof Symbol)) {\n o.push(sym = v.valueOf());\n } else {\n s = String(v);\n s && o.push(s);\n }\n s = strs[i+1];\n s && o.push(s);\n }\n if (sym) {\n if (o.length == 1) { return o[0]; }\n throw new TypeError(\"If a symbol is intended to be used as a property key, then no other strings must be present in the tagged template literal.\", {cause: o});\n }\n try {\n return o.join(\"\");\n } finally {\n o.length = 0;\n o = undefined;\n }\n}, {check(strings) {\n return Array.isArray(strings) && Array.isArray(strings.raw);\n}})","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":161,"value":"$4b","pinned":false,"hidden":false,"mode":"html","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"","database":"$undefined"},{"id":350,"value":"primType = {\n const prims = new Map(Object.entries({\n boolean: Boolean,\n number: Number,\n bigint: BigInt,\n string: String,\n symbol: Symbol,\n function: Function\n }).map(entry => entry.reverse()));\n invalidation.then(() => prims.clear());\n \n return primType;\n\n function primType(v) {\n let t = typeof v;\n if (v === null) { return \"null\"; }\n if (t === \"object\") {\n for (let [cls, prim] of prims) {\n if (v instanceof cls) { return prim; }\n }\n }\n return t;\n }\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"}],"files":"$W4c","stdlib":"1"}} 45:"$44:body"

${Promise.prototype.call.name} 🏷️

${Promise.prototype.do.name} 🏷️

${Promise.prototype.check.name} 🏷️

${Promise.prototype.get.name} 🏷️

${Promise.prototype.getSafe.name} 🏷️

usage

settled

`${Promise.prototype.call.name}` 🏷️

`${Promise.prototype.do.name}` 🏷️

`${Promise.prototype.check.name}` 🏷️

`${Promise.prototype.get.name}` 🏷️

`${Promise.prototype.getSafe.name}` 🏷️

`settled`