PopClip Extensions

This document applies to PopClip 2021.11 (3785). See also: Changelog

NEW: Check the Extensions Development section of the new PopClip Forum to keep up-to date about extensions development, to ask questions, and to help others.

Table of Contents

• PopClip Extensions
• Table of Contents
• Introduction
  • License
  • Credits
  • Contributing
  • Extension Signing
  • Debug Output
• Extension Snippets
  • Extension Snippets Examples
• Anatomy of a PopClip Extension
  • Types of Actions
  • Filtering
  • The .popclipext package
  • About .popclipextz files
  • The Config file
  • Field names
• Icons
  • Text-based icons
  • Examples of symbols and text-based icons
• The Config file structure
  • About the "Localizable String" type
  • Extension properties
  • Action properties
  • Shortcut action properties
  • Service action properties
  • URL action properties
  • Key Press action properties
  • AppleScript action properties
  • Shell Script action properties
  • JavaScript action properties
  • The JavaScript Engine
  • Error handling and debugging
  • Asynchronous operations
  • Network access from JavaScript
  • Async/await
  • TypeScript
  • JavaScript reference
• Meanings of particular fields
  • The requirements array
  • Note on side effect of requirements field
  • The before and after strings
  • The app dictionary
  • The options array
• Using Scripts
  • Script Fields
  • Example AppleScript File
  • Example Shell Script Files
  • Shell Script Testing
  • Indicating Errors
• Key Combo format
  • Key code string format
  • Key code dictionary format
• Field name mapping

Introduction

PopClip Extensions add extra actions to PopClip.

This repository contains the documentation for making your own extensions (this readme file) as well as the source files for the extensions published on the main PopClip Extensions page. Plus bonus extensions not published on that page.

License

All extension source files are published under the MIT License (see LICENSE.txt) unless noted otherwise in the readme files of individual extensions.

Credits

All the extensions and documentation were created by Nick Moore, except where stated. Individual extension credits are included in a readme file with the extension.

Contributing

Thank you for contributing! New extensions can be contributed by pull request, as a new folder in the source folder of this repo. Alternatively simply by zip up your extension and email it to me. Contributors, please note the following:

• By contributing to this repo, you agree that your contribution may be published at PopClip Extensions.
• Submitting to the repo does not guarantee publication on the website. (And if I don't publish your extension there it doesn't mean your extension is bad. I curate that list for the general audience and your extension just might be more technical or niche.)
• I may make changes to any extension submitted.
• Don't worry about signing the extension, I will take care of that.

Extension Signing

By default, PopClip will display a warning dialog when you try to install your own extension, because it is not digitally signed.

If you find this gets annoying while you are testing your work, you can turn off the warning. Run the following command at the Terminal, then Quit and restart PopClip:

defaults write com.pilotmoon.popclip LoadUnsignedExtensions -bool YES

Please be aware that PopClip extensions can contain arbitrary executable code. Be careful about the extensions you create, and be wary about loading extensions you get from someone else.

(PopClip will never load unsigned extensions whose identifier has a com.pilotmoon. prefix, which is reserved for 'official' extensions. When basing your own extension off such an extension, you will need to change the identifier.)

Debug Output

To help you when creating extensions, PopClip can be configured to write script output and debug info to be viewed with the Console app. To enable it, run this command in Terminal, then Quit and restart PopClip:

defaults write com.pilotmoon.popclip EnableExtensionDebug -bool YES

Extension Snippets

PopClip 2021.11 supports a new, simplified way to create and share simple extensions called "Extension Snippets".

Here is an example extension snippet:

# popclip extension to search Emojipedia
name: Emojipedia
icon: search filled E
url: https://emojipedia.org/search/?q=***

When you select the above text, PopClip will offer an "Install Extension" action. Clicking it will install the above extension directly, without any need for config files or a .popclipext folder.

The format of a snippet is a simply a regular PopClip extension config in YAML format, with the addition of a comment header beginning with # popclip (with or without a space, not case sensitive).

All features of regular extensions can be used, with the limitation that additional files (such as icon files or scripts) cannot be included. Extension snippets can be a maximum of 1000 characters.

If the extension is of type Shortcut, Service, URL, Key Combo or JavaScript (without network entitlement), the extension snippet will install without the usual "unsigned extension" prompt. AppleScript snippets, and JavaScript snippets with the network entitlement, will still give the unsigned warning.

Full Shell Script extensions can't be expressed as snippets, although you can use an AppleScript to run a simple shell script as a string literal (see example below).

In the absence of an explicit identifier field, the extension is identified by its name. Installing another extension with the same name (or identifier) will overwrite an existing one.

Extension Snippets Examples

A Shortcuts example:

# popclip shortcuts example
name: Run My Shortcut
icon: symbol:moon.stars # Apple SF Symbols
macos version: '12.0' # shortcuts only work on Monterey and above!
shortcut name: My Shortcut Name

An AppleScript example, running a shell script:

# popclip shellscript nested in an applescript 
name: Say
applescript: do shell script "say '{popclip text}'"

A multi-line AppleScript example (the pipe character begins a YAML multi-line string, and the following lines must all be indented with two spaces - not tabs!):

# PopClip LaunchBar example
name: LaunchBar
icon: LB
applescript: | # pipe character begins a multi-line string
  tell application "LaunchBar"
    set selection to "{popclip text}"
  end tell
# the above lines are indented with two spaces. no tabs allowed in YAML!

A JavaScript example, including multiple actions:

# popclip js + multi action example
name: Markdown Formatting
requirements: [text, paste]
actions:
- title: Markdown Bold # note: actions have a `title`, not a `name`
  icon: circle filled B
  javascript: popclip.pasteText('**' + popclip.input.text + '**')
- title: Markdown Italic
  icon: circle filled I
  javascript: popclip.pasteText('*' + popclip.input.text + '*')  

A Key Combo example:

# popclip
name: Keypress Example
key combo: command option J

A Service example:

# popclip
name: Make Sticky
service name: Make Sticky

A more complex Key Combo example with a raw key code and using some more fields:

# popclip extension snippet - more complex example
name: Paste and Enter
icon: square monospaced ↵
requirements: [paste]
before: paste
key combo:
  key code: 0x24 # see https://bit.ly/3wSkQ9I
  modifiers: 0 # `modifiers` is required even if zero

Anatomy of a PopClip Extension

Types of Actions

There are seven kinds of actions supported by PopClip extensions.

Filtering

Extensions have access to the following filtering mechanisms, to help prevent actions appearing when they are not useful:

• Filter by matching a regular expression.
• Filter by application (either include or exclude).
• Filter by whether cut, copy or paste is available.
• Filter by whether the text contains a URL, email address or file path.
• Filter by the current values of the extensions's options.

The .popclipext package

A PopClip extension consists of a configuration file called either Config.json, Config.yaml or Config.plist, plus (optional) additional files such as icons and scripts, all contained in a directory whose name ends with .popclipext. Such a directory will be treated as a package by Mac OS X. To view the contents of a package, right click it in Finder and choose 'Show Package Contents'.

If you double-click a .popclipext package, PopClip will attempt to load and install it. PopClip stores its installed extensions in ~/Library/Application Support/PopClip/Extensions/.

Here is an example package structure, the 'Say' extension:

Say.popclipext                  -- Containing folder
   _Signature.plist             -- Signature (official Pilotmoon extensions only)
   Config.plist                 -- Main configuration file
   say.sh                       -- Script file
   speechicon.png               -- Icon file

About .popclipextz files

For distribution, an extension package folder may be zipped and renamed with the extension .popclipextz. You can examine an existing PopClip extension by renaming it with a .zip extension and unzipping it, to reveal a .popclipext package.

The Config file

Every extension must contain a Config file, in either JSON, YAML or plist format.

The Config file must define a single dictionary at its root, which defines the extension. Although the three formats are different, they all can be used to define a dictionary mapping string keys to values. The values can be strings, numbers, booleans, arrays or other dictionaries. (In this documentation the term 'field' is used to refer to a key/value pair in a dictionary.)

The choice of format does not affect the extension functionality in any way, so you can choose whichever format you prefer to work with. (Plist was the original config file format for PopClip extensions for many years, and the JSON and YAML formats were added later.)

Field names

Field names in this document are given in a lowercase form with words separated by spaces, such as required apps. However, PopClip will treat field names in any of the following formats as equivalent:

• Lowercase with spaces: e.g. required apps
• Mixed case with spaces: e.g. Required Apps (this is the original naming format prior to PopClip 2021.11)
• Camel case: e.g. requiredApps
• Pascal case: e.g. RequiredApps
• Snake case: e.g. required_apps
• Kebab case: e.g. required-apps
• Constant case: e.g. REQUIRED_APPS

Rules for transformation are as defined by case-anything, which PopClip uses.

Older versions of PopClip used different names for some fields. Where there is a new name, the old name is also still accepted. A table of old and new is given in Field name mapping.

Icons

Icons may be specified in the icon fields in a few different ways:

• As a filename: <filename>.png or <filename>.svg specifies an image file within the extension package, in either PNG or SVG format. You can create your own with an image editor, or you could use icons from a website like The Noun Project] or the macOS app IconJar. Please include any applicable copyright attribution in a README file.

• As an SF Symbol: symbol:<symbol name> specifies an SF Symbols identifier, for example symbol:flame. Symbols are only available on macOS 11.0 and above. Also note that some symbols require higher macOS versions as indicated in the "Availability" panel in Apple's SF Symbols browser app. (If the symbol does not exist on the version of macOS the user is running, it will be as if no icon was specified. Therefore, you should specify an appropriate macos version when using a symbol icon.)

• As a text-based icon: Using a special format, you can instruct PopClip to generate a text-based icon (see below).

PNG and SVG icons should be square and monochrome. The image should be black, on a transparent background. You can use opacity to create shading. PNG icons should be at least 256x256 pixels in size.

Text-based icons

Text-based icons can up to three characters, on their own or within an enclosing shape. They are specified by space-separated keywords followed by the characters to draw.

The following keywords define an enclosing shape (only one of these should be included):

The following keywords modify the way the text is drawn:

Examples of symbols and text-based icons

Text String	Icon Generated
symbol:flame
symbol:hand.raised
symbol:signpost.right
A or text A
circle 1
circle filled 本
square xyz
square filled !
square filled monospaced ()
search E
search filled monospaced £

As a handy tool, the extension IconPreview.popclipextz in this repo will display the icon for a text string you select.

The Config file structure

About the "Localizable String" type

Fields shown as "Localizable String" may be either a string or a dictionary. If you supply a string, that string is always used. If you supply a dictionary mapping language codes (en, fr, zh-hans, etc.) to a string, PopClip will display the string for the user's preferred language if possible, with fallback to the en string.

Extension properties

The following fields are used at the top level of the configuration to define properties of the extension itself. All fields are optional.

If neither actions nor action is defined, PopClip will look at the top level of the plist for an action definition.

Action properties

The following fields define properties common to all actions. All fields are optional.

Shortcut action properties

A shortcut action is defined by the presence of a shortcut name field. Shortcut actions are only available on macOS 12.0 and above.

The selected text will be sent as input to the service, and any text returned by the shortcut will be available to the after action.

Service action properties

A service action is defined by the presence of a service name field.

The name is as shown in the Services menu, for example Add to Deliveries. In some cases, you may need to look into the Info.plist of the application to find the name defined in there under NSServices → NSMenuItem. An example of this is the Make New Sticky Note service which must be called as Make Sticky.

URL action properties

A URL action is defined by the presence of a url field. You can open any type of URL, not just web URLs.

You can also put options in the URL, in the same format as for AppleScripts. For example, http://translate.google.com/#auto%7C{popclip option language}%7C{popclip text}.

The string *** will work as a shorthand for {popclip text}.

Key Press action properties

A Key Press action is defined by the presence of a key combo field.

The key press is delivered at the current app level, not at the OS level. This means PopClip is not able to trigger global keyboard shortcuts. So for example PopClip can trigger ⌘B for "bold" (if the app supports that) but not ⌘Tab for "switch app".

AppleScript action properties

An AppleScript action is defined by the presence of either an applescript file field or an applescript field, as follows.

Within the AppleScript, use "{popclip text}" as the placeholder for the selected text. PopClip will replace the placeholders with the actual text before executing the script. Other fields are also available: see Script Fields.

You can return a value from the script and have PopClip act upon it by defining an after key. See also Example AppleScript File.

Shell Script action properties

An Shell Script action is defined by the presence of a shell script file field, with an optional script interpreter field.

The the current working directory will be set to the package directory. Within the script, access the selected text as $POPCLIP_TEXT, and other variables as described in Script Fields. You can return a value from the script and have PopClip act upon it by defining an after key. See Example Shell Script File.

JavaScript action properties

Note: JavaScript extensions are brand new and it will take me some time to document everything fully. The following gives the basics. Please bear with me!

A note on "module-based" extensions: There is a further kind of extension I am calling a module-based extension. In a module-based extension, the extension itself is defined by a JavaScript module. This allows greater flexibility and customization of the extension, at the cost of being more complex to explain and to use. This section describes how JavaScript fits in to the "classic" extension structure, which is the easiest to explain and to use for simple tasks.

A JavaScript action is defined by the presence of either a javascript file field or a javascript field, as follows.

PopClip loads the file or the string and evaluates it as if it were a function body. Scripts can by return results by finishing with a return statement. A quick example:

# popclip (this is exactly how the published Uppercase extension works)
name: Uppercase
icon: square filled AB
javascript: return popclip.input.text.toUpperCase()
after: paste-result

JS scripts have access to PopClip's state and can perform actions, via the properties and methods of the popclip global object. There is draft documentation here: PopClip Extensions JavaScript Reference.

Here is a quick reference for some commonly needed stuff:

• popclip.input.text - the full selected text
• popclip.input.matchedText - the part of the text matching the requirement or regex
• popclip.input.html - the html backing the selection (needs captureHtml field set)
• popclip.input.markdown - the markdownified html (needs captureHtml field set)
• popclip.input.data.urls - array of detected web URLs (similar to POPCLIP_URLS in shell scripts)
• popclip.context.browserUrl and popclip.context.browserTitle - hopefully self-explanatory
• popclip.modifiers.command, popclip.modifiers.option, popclip.modifiers.shift, popclip.modifiers.control - booleans for modifier keys pressed
• popclip.pasteText('string') - paste the string (similar to paste-result)
• popclip.copyText('string') - copy the string (similar to copy-result)
• popclip.showText('string') - show the string (similar to show-result)
• popclip.openUrl() - open a URL, similar to a URL extension
• popclip.pressKey() - presses a key combo, similar to a key press extension
• print() - global debug printing function

The JavaScript Engine

PopClip's JavaScript engine is Apple's JavaScriptCore, which is part of macOS. The available language features and core libraries depend on which version of macOS PopClip is running on. The minimum requirement for PopClip is currently macOS 10.13.6, and scripts can assume it is safe to use all features marked as "Safari 10.1" and below in MDN (example), which corresponds to ES2017 specification. Newer language features may be available on higher versions of macOS.

Error handling and debugging

In general you don't need to worry too much about catching and handling errors. If the script throws an error, PopClip simply shows the shaking-'X'. Debug output can be viewed in the console as described in Debug Output.

Asynchronous operations

Usually, the JavaScript code will be run synchronously (i.e., as a single code block that PopClip waits to finish). However PopClip provides implementations of XMLHttpRequest and setTimeout, which are asynchronous. If a script uses these, PopClip will show its spinner and wait until the last asynchronous operation has finished. In such a case the returned value from the script (if any) is the return value of the last function to complete. For example:

# popclip async example
name: Async Test
javascript: | 
  setTimeout(() => { 
    return 'bar'
  }, 1000) // 1 second delay
  return 'foo'
after: show-result # result shown will be 'bar', not 'foo'

During asynchronous operations, clicking PopClip's spinner will cancel all current operations.

Network access from JavaScript

PopClip provides its own implementation of XMLHttpRequest (XHR). To use it, you need to include the network entitlement in the entitlements field of the config file.

PopClip is also bundled with the HTTP library axios, which you can load using const axios = require('axios'). This is a lot easier to use than XHR!

Some limitations to be aware of:

• Due to macOS's App Transport Security, PopClip can only access https URLs. Attempting to access http URLs results in a network error from XHR.
• PopClip's implementation of XHR currently can only download text MIME types. Binary data will fail.

Here's an example extension snippet that downloads a selected URL's contents, and copies it to the clipboard:

# popclip JS network example
name: Download Text
icon: symbol:square.and.arrow.down.fill
requirements: [url]
entitlements: [network]
javascript: |
  const axios = require('axios')
  const response = await axios.get(popclip.input.data.urls[0]) // throws for non-2xx status
  return response.data
after: copy-result

Async/await

The axios library is promise-based, and you'll notice that the above example uses the await keyword. That's possible because, internally, PopClip runs the JS code wrapped as an async function, and resolves any returned promises itself, allowing you to use await to get nice clean code like the above.

TypeScript

When looking at the extensions in this repo I have made, you will see .ts files. These are TypeScript source code, which compiles down to JavaScript. I prefer to use TS than raw JS as it helps me to write correct code, aided by the TypeScript definitions file popclip.d.ts. The TypeScript configuration I use is in tsconfig.json.

JavaScript reference

There are loads of JavaScript references out there, but the one I use and recommend is MDN.

Meanings of particular fields

The requirements array

These are the values supported by the requirements array. Additionally, you can prefix any requirement with ! to negate it.

Note on side effect of requirements field

When using a url, email or path requirement, the text passed to the action will be modified.

• For url requirement, only the matching URL will be passed, and it will be expanded to its full form, with https:// prepended if no scheme is specified. For example, if the selected text is go to apple.com, the text passed to the action will be https://apple.com.
• For email requirement, the only the matching email address will be passed to the action.
• For path requirement, only the matching path will be passed to the action, and it will be standardized form with ~ and .. expanded. For example ~/Documents will be passed as /Users/username/Documents.

In all three cases, actions can assume that their input is a valid web URL, email address or path.

Shell Scripts and AppleScripts can still access the original text in the POPCLIP_FULL_TEXT and {popclip full text} fields. JavaScript actions will find the modified text as popclip.input.matchedText and the full text as popclip.input.text.

The before and after strings

The cut, copy and paste keys can be used as the before string. All the values can be used as the after string.

The app dictionary

The app field is a dictionary with the following stricture:

The options array

Options are presented to the user in a preferences user interface window and are saved in PopClip's preferences on behalf of the extension. Options appear in the UI in the order they appear in the options array. An option dictionary has the following structure.

Using Scripts

Script Fields

These strings are available in Shell Script and AppleScript extensions. Where no value is available, the field will be set to an empty string.

Example AppleScript File

Important: AppleScript files must be in plain text format. Save as .applescript, not .scpt.

Here is an example of an AppleScript file (this one is for the 'TextEdit' extension):

tell application "TextEdit"
 activate
 set theDocument to make new document
 set text of theDocument to "{popclip text}"
end tell

Example Shell Script Files

Here is an example of an extension shell script (this one is for 'Say'):

#!/bin/sh
echo $POPCLIP_TEXT | say  # pipe text to 'say' command

A shell script can return a string back to PopClip via to stdout. For example:

#!/bin/sh
echo "Hello, ${POPCLIP_TEXT}!"  # echo to stdout

A ruby example:

#!/usr/bin/env ruby
input=ENV['POPCLIP_TEXT']
print input.upcase  # make the text ALL CAPS

Shell Script Testing

While developing a script, you can test it from the command line by exporting the required variables. For example:

export POPCLIP_TEXT="my test text"
export POPCLIP_OPTION_FOO="foo"
./myscript

Indicating Errors

Scripts may indicate success or failure as follows:

Key Combo format

Key presses may be expressed in either of two ways.

Key code string format

The string format is a convenient human-readable format that can specify a key character and modifiers. It is simply a space-separated list of one or more modifiers (order does not matter), followed by a single character to press.

For example: option shift . or command B

The key code string is not case sensitive. (Key character will automatically be converted to uppercase).

The modifiers are specified with the following keywords:

Key code dictionary format

The dictionary format is also able to specify modifiers plus a key character or key code.

Note: Exactly one of keyChar or keyCode should be specified. Not both.

Table of modifier combinations:

Field name mapping

Some field names were different in older versions of PopClip. Others have alternative allowable forms to avoid confusion when expressed camel case, e.g. appleScriptFile is mapped to applescriptFile.

PopClip applies the following mapping to field names loaded from the config file:

Also, if the field name has the prefix extension or option, it is removed.