Code Reuse

[josephcrawfordSRH]

I am wondering if a script can be a folder such as script-name/script-1.js, script-name/script-2.js`? I will explain my use case. I have a script that can be executed by shortcut and one of the questions is whether or not I want to open a new ide window. I would prefter to have a base-script with a method that script-1 and script-2 could import passing a flag so that all of this code would not have to be replicated in two scripts just for a single command flag change.

code -r dir/
code -n dir/

that is all that is really changing between the scrips so if I could have script-1 import a method from base.js and just pass openInBranch(true) or openInbranch(false) or something to that effect as to whether to open in a new window would be beneficial.

[johnlindquist]

The convention is to add shared/library code to file in ~/.kenv/lib:

// ~/.kenv/lib/my-lib.ts
import "@johnlindquist/kit"
export const getName = async () => {
  return await arg("Enter name")
}

Then import them into scripts:

// ~/.kenv/scripts/my-script.ts
import "@johnlindquist/kit"
import { getName } from "../lib/my-lib"

let name = await getName()

[josephcrawfordSRH]

@johnlindquist ok but I want to share this with team members, if I do that I would need to have them go through several setup steps vs just copy a directory over. Is there a better way to share if I put common code in the lib/ folder? This is only going to be common to these two scripts and basically will only be a wrapper of what I have now in a single script so that both scripts could use it telling it whether or not it was a new window.

I know it's difficult not seeing all of the code and I do plan to share this in the future with the community, but I will need to make sure there is nothing work-specific in the code before I do that which is why I have been hesitant to share the full script currently.

I currently have it in this structure

// ~/.kenv/scripts/open-project-on-branch.js
// Name: Open Project On Branch
// Shortcut: cmd+;
import "@johnlindquist/kit";

// irrelevant code removed from here

let windowFlag = "-n";

if (await arg("Open in a new window?", ["Yes", "No"]) === "No") {
  windowFlag = "-r";
}

await exec(`${code} ${windowFlag} ${projectPath}`);

// irrelevant code removed from here

As you can see i removed quite a bit of the code where I have the comments, that would be common code between the scripts but I was thinking that I could do something like this

// ~/.kenv/open-project-on-branch/base.js
import "@johnlindquist/kit";

export async function Opob(newWindow = false) {
  // irrelevant code removed from here

  let windowFlag = "-r";

  if (newWindow) {
    windowFlag = "-n";
  }

  await exec(`${code} ${windowFlag} ${projectPath}`);

  // irrelevant code removed from here
}

// ~/.kenv/open-project-on-branch/newWindow.js
// Name: Open Project On Branch (New Window)
// ShortCut: shift+;
import { Opob } from './base.js';

await Opob(true);

// ~/.kenv/open-project-on-branch/newWindow.js
// Name: Open Project On Branch (Existing Window)
// ShortCut: shift+cmd+;
import { Opob } from './base.js';

await Opob(false);

This code would not be shared for many scripts which is why I was wondering if this would work? Then I could just share the base folder with team members and they could jump right in.

Am I thinking about sharing in the wrong process flow, is there a better way?

[johnlindquist]

Here's how I think about code sharing:

1. script level
2. kenv level

You can share a group of scripts/libs in a "kenv" and put them under version control.

Assuming you're on the 2.0 RC:

• Type kenv new to setup a new kenv. Add whatever scripts libs, push it to a repo
• Have your users type kenv clone to checkout your kenv

3. npm level
   Publish your libs, etc to npm so anyone can use them

"base" scripts

You can create a "base" script in that has the // Exclude to prevent it from showing in the main menu:

// Name: Testing Run Base
// Exclude: true

import "@johnlindquist/kit"

let value = await arg("I will be auto-filled with the 'run' values of other scripts")
inspect(value)

Then run that script from other scripts:

// Name: Testing Run One

import "@johnlindquist/kit"

await run("testing-run-base", "one")

// Name: Testing Run Two

import "@johnlindquist/kit"

await run("testing-run-base", "two")

[josephcrawfordSRH]

Yes that would work except my base asks several questions using arg so I think I would be better off going the kenv route and using libs. I will think this through and try it out with 2.0 rc when I have free time tomorrow evening.

Thank you.