🫚 gember

Generate components, helpers, modifiers and services in v1/v2 apps/addons.

ℹ️ Only supports .gjs (default) and .gts files for components.

Installation

npm

npm install -D @bertdeblock/gember

bun

bun add -D @bertdeblock/gember

pnpm

pnpm add -D @bertdeblock/gember

yarn

yarn add -D @bertdeblock/gember

Usage

💡 Run pnpm gember --help for all available generators.

💡 Run pnpm gember <generator-name> --help for all available generator options.

Generating components

pnpm gember component --help # for all available options

# examples:
pnpm gember component foo
pnpm gember component foo --class-based # or `--class`
pnpm gember component foo --nested
pnpm gember component foo --path="src/-private"
pnpm gember component foo --typescript # or `--ts`

Generating helpers

pnpm gember helper --help # for all available options

# examples:
pnpm gember helper foo
pnpm gember helper foo --class-based # or `--class`
pnpm gember helper foo --path="src/-private"
pnpm gember helper foo --typescript # or `--ts`

Generating modifiers

pnpm gember modifier --help # for all available options

# examples:
pnpm gember modifier foo
pnpm gember modifier foo --class-based # or `--class`
pnpm gember modifier foo --path="src/-private"
pnpm gember modifier foo --typescript # or `--ts`

Generating services

pnpm gember service --help # for all available options

# examples:
pnpm gember service foo
pnpm gember service foo --path="src/-private"
pnpm gember service foo --typescript # or `--ts`

Configuration

gember supports the following config files:

• gember.config.js
• gember.config.cjs
• gember.config.mjs

A gember config file must export a gember config object, or a sync/async function that returns a gember config object:

// gember.config.js

export default {};

// or:
export default () => ({});

// or:
export default async () => ({});

Configuration Signature

export type Config = {
  generators?: {
    component?: {
      // Generate a `class-based` component, instead of a `template-only` component:
      classBased?: boolean;
      // Copy the generated component to the clipboard, instead of writing it to disk:
      copy?: boolean;
      // Log the generated component to the console, instead of writing it to disk:
      log?: boolean;
      // The component's name:
      name?: string;
      // Generate a nested colocated component, e.g. `foo/bar/index.gts`:
      nested?: boolean;
      // Generate a component at a custom path, e.g. `--path=src/-private`:
      path?: string;
      // Generate a `.gts` component, instead of a `.gjs` component:
      typescript?: boolean;
    };
    "component-test"?: {
      // Copy the generated component-test to the clipboard, instead of writing it to disk:
      copy?: boolean;
      // Log the generated component-test to the console, instead of writing it to disk:
      log?: boolean;
      // The component-test's name:
      name?: string;
      // Generate a component-test at a custom path, e.g. `--path=src/-private`:
      path?: string;
      // Generate a `.gts` component-test, instead of a `.gjs` component-test:
      typescript?: boolean;
    };
    helper?: {
      // Generate a `class-based` helper, instead of a `function-based` helper:
      classBased?: boolean;
      // Copy the generated helper to the clipboard, instead of writing it to disk:
      copy?: boolean;
      // Log the generated helper to the console, instead of writing it to disk:
      log?: boolean;
      // The helper's name:
      name?: string;
      // Generate a helper at a custom path, e.g. `--path=src/-private`:
      path?: string;
      // Generate a `.ts` helper, instead of a `.js` helper:
      typescript?: boolean;
    };
    "helper-test"?: {
      // Copy the generated helper-test to the clipboard, instead of writing it to disk:
      copy?: boolean;
      // Log the generated helper-test to the console, instead of writing it to disk:
      log?: boolean;
      // The helper-test's name:
      name?: string;
      // Generate a helper-test at a custom path, e.g. `--path=src/-private`:
      path?: string;
      // Generate a `.gts` helper-test, instead of a `.gjs` helper-test:
      typescript?: boolean;
    };
    modifier?: {
      // Generate a `class-based` modifier, instead of a `function-based` modifier:
      classBased?: boolean;
      // Copy the generated modifier to the clipboard, instead of writing it to disk:
      copy?: boolean;
      // Log the generated modifier to the console, instead of writing it to disk:
      log?: boolean;
      // The modifier's name:
      name?: string;
      // Generate a modifier at a custom path, e.g. `--path=src/-private`:
      path?: string;
      // Generate a `.ts` modifier, instead of a `.js` modifier:
      typescript?: boolean;
    };
    "modifier-test"?: {
      // Copy the generated modifier-test to the clipboard, instead of writing it to disk:
      copy?: boolean;
      // Log the generated modifier-test to the console, instead of writing it to disk:
      log?: boolean;
      // The modifier-test's name:
      name?: string;
      // Generate a modifier-test at a custom path, e.g. `--path=src/-private`:
      path?: string;
      // Generate a `.gts` modifier-test, instead of a `.gjs` modifier-test:
      typescript?: boolean;
    };
    service?: {
      // Copy the generated service to the clipboard, instead of writing it to disk:
      copy?: boolean;
      // Log the generated service to the console, instead of writing it to disk:
      log?: boolean;
      // The service's name:
      name?: string;
      // Generate a service at a custom path, e.g. `--path=src/-private`:
      path?: string;
      // Generate a `.ts` service, instead of a `.js` service:
      typescript?: boolean;
    };
    "service-test"?: {
      // Copy the generated service-test to the clipboard, instead of writing it to disk:
      copy?: boolean;
      // Log the generated service-test to the console, instead of writing it to disk:
      log?: boolean;
      // The service-test's name:
      name?: string;
      // Generate a service-test at a custom path, e.g. `--path=src/-private`:
      path?: string;
      // Generate a `.ts` service-test, instead of a `.js` service-test:
      typescript?: boolean;
    };
    "acceptance-test"?: {
      // Copy the generated acceptance-test to the clipboard, instead of writing it to disk:
      copy?: boolean;
      // Log the generated acceptance-test to the console, instead of writing it to disk:
      log?: boolean;
      // The acceptance-test's name:
      name?: string;
      // Generate a acceptance-test at a custom path, e.g. `--path=src/-private`:
      path?: string;
      // Generate a `.ts` acceptance-test, instead of a `.js` acceptance-test:
      typescript?: boolean;
    };
  };

  hooks?: {
    // A hook that will be executed post running a generator:
    postGenerate?: (info: {
      entityName: string;
      files: GeneratorFile[];
      generatorName: string;
    }) => Promise<void> | void;
  };

  // Use TypeScript by default for all generators:
  typescript?: boolean;
};