tegaki 0.0.1 → 0.2.2

package/src/types.test.ts

@@ -0,0 +1,92 @@
+import { describe, test } from 'bun:test';
+import type { TegakiEffects } from './types.ts';
+
+function assertType<const E extends TegakiEffects<E>>(_value: E) {}
+
+describe.skip('TegakiEffects', () => {
+  test('known key with config', () => {
+    assertType({ glow: { radius: 5 } });
+    assertType({ wobble: { amplitude: 2, frequency: 3 } });
+    assertType({ gradient: { colors: ['#ff0000', '#00ff00'] } });
+    assertType({ gradient: { colors: 'rainbow', saturation: 80 } });
+    assertType({ taper: { startLength: 0.2, endLength: 0.1 } });
+    assertType({ pressureWidth: {} });
+  });
+
+  test('known key with boolean shorthand', () => {
+    assertType({ glow: true });
+    assertType({ wobble: true });
+    assertType({ taper: true });
+    assertType({ gradient: true });
+  });
+
+  test('known key with explicit effect field', () => {
+    assertType({ glow: { effect: 'glow', radius: 10 } });
+  });
+
+  test('known key with order', () => {
+    assertType({ glow: { radius: 5, order: 1 } });
+  });
+
+  test('custom key with explicit effect', () => {
+    assertType({ outerGlow: { effect: 'glow', radius: 20 } });
+    assertType({ innerGlow: { effect: 'glow', radius: 5, order: 1 } });
+  });
+
+  test('multiple effects combined', () => {
+    assertType({
+      glow: { radius: 20 },
+      innerGlow: { effect: 'glow', radius: 5, order: 1 },
+      wobble: true,
+      gradient: { colors: 'rainbow' },
+      taper: { startLength: 0.2 },
+    });
+  });
+
+  test('glow with offset (shadow)', () => {
+    assertType({ glow: { radius: 8, offsetX: 2, offsetY: 2, color: '#000000' } });
+  });
+
+  test('wobble with noise mode', () => {
+    assertType({ wobble: { amplitude: 2, mode: 'noise' } });
+    assertType({ wobble: { amplitude: 2, mode: 'sine' } });
+  });
+
+  test('custom key without effect field is rejected', () => {
+    // @ts-expect-error — unknown key must have explicit `effect`
+    assertType({ myGlow: { radius: 5 } });
+  });
+
+  test('wrong params for effect are rejected', () => {
+    // @ts-expect-error — amplitude is not a glow param
+    assertType({ glow: { amplitude: 5 } });
+  });
+
+  test('known key with wrong effect name is rejected', () => {
+    // @ts-expect-error — glow key cannot have effect: 'wobble'
+    assertType({ glow: { effect: 'wobble' } });
+  });
+
+  test('invalid effect name is rejected', () => {
+    // @ts-expect-error — 'sparkle' is not a valid effect
+    assertType({ myEffect: { effect: 'sparkle' } });
+  });
+
+  test('singleton effect cannot be used with custom key', () => {
+    // @ts-expect-error — pressureWidth is singleton, cannot be duplicated via custom key
+    assertType({ myPressure: { effect: 'pressureWidth', strength: 0.5 } });
+    // @ts-expect-error — wobble is singleton, cannot be duplicated via custom key
+    assertType({ myWobble: { effect: 'wobble', amplitude: 2 } });
+    // @ts-expect-error — gradient is singleton, cannot be duplicated via custom key
+    assertType({ myGradient: { effect: 'gradient', colors: 'rainbow' } });
+    // @ts-expect-error — taper is singleton, cannot be duplicated via custom key
+    assertType({ myTaper: { effect: 'taper', startLength: 0.2 } });
+  });
+
+  test('singleton effect works with its own key', () => {
+    assertType({ pressureWidth: { strength: 0.5 } });
+    assertType({ pressureWidth: true });
+    assertType({ taper: { startLength: 0.2 } });
+    assertType({ gradient: { colors: 'rainbow' } });
+  });
+});

package/src/types.ts

@@ -0,0 +1,114 @@
+export type LineCap = 'round' | 'butt' | 'square';
+
+export interface Point {
+  x: number;
+  y: number;
+}
+
+export interface TimedPoint extends Point {
+  t: number;
+  width: number;
+}
+
+export interface BBox {
+  x1: number;
+  y1: number;
+  x2: number;
+  y2: number;
+}
+
+export interface Stroke {
+  points: TimedPoint[];
+  order: number;
+  length: number;
+  animationDuration: number;
+  delay: number;
+}
+
+export interface GlyphData {
+  char: string;
+  unicode: number;
+  advanceWidth: number;
+  boundingBox: BBox;
+  path: string;
+  skeleton: Point[][];
+  strokes: Stroke[];
+  totalLength: number;
+  totalAnimationDuration: number;
+}
+
+export interface FontOutput {
+  font: {
+    family: string;
+    style: string;
+    unitsPerEm: number;
+    ascender: number;
+    descender: number;
+    lineCap: LineCap;
+  };
+  glyphs: Record<string, GlyphData>;
+}
+
+export interface PathCommand {
+  type: 'M' | 'L' | 'Q' | 'C' | 'Z';
+  x: number;
+  y: number;
+  x1?: number;
+  y1?: number;
+  x2?: number;
+  y2?: number;
+}
+
+export interface TegakiGlyphData {
+  advanceWidth: number;
+  strokes: {
+    points: { x: number; y: number; t: number; width: number }[];
+    delay: number;
+    animationDuration: number;
+  }[];
+}
+
+type BaseEffectConfig = { enabled?: boolean };
+
+/** A length value: plain number is pixels, string `"${number}em"` is relative to font size. */
+export type CSSLength = number | `${number}em`;
+
+export type TegakiEffectConfigs = {
+  glow: BaseEffectConfig & { radius?: CSSLength; color?: string; offsetX?: number; offsetY?: number };
+  wobble: BaseEffectConfig & { amplitude?: number; frequency?: number; mode?: 'sine' | 'noise' };
+  pressureWidth: BaseEffectConfig & { strength?: number };
+  taper: BaseEffectConfig & { startLength?: number; endLength?: number };
+  gradient: BaseEffectConfig & { colors?: string[] | 'rainbow'; saturation?: number; lightness?: number };
+};
+
+export type TegakiEffectName = keyof TegakiEffectConfigs;
+
+/** Effects that can only appear once (cannot be used with custom keys). */
+export type TegakiSingletonEffectName = 'pressureWidth' | 'wobble' | 'taper' | 'gradient';
+
+/** Effects that can be duplicated with custom keys. */
+export type TegakiMultiEffectName = Exclude<TegakiEffectName, TegakiSingletonEffectName>;
+
+type TegakiCustomEffect = {
+  [K in TegakiMultiEffectName]: TegakiEffectConfigs[K] & { effect: K; order?: number };
+}[TegakiMultiEffectName];
+
+/** Validates an effects object: known keys infer `effect`, unknown keys require it (singleton effects excluded). */
+export type TegakiEffects<T> = {
+  [K in keyof T]: K extends TegakiEffectName
+    ? (TegakiEffectConfigs[K] & { effect?: K; order?: number }) | boolean
+    : TegakiCustomEffect | boolean;
+};
+
+export interface TegakiBundle {
+  family: string;
+  lineCap: LineCap;
+  fontUrl: string;
+  unitsPerEm: number;
+  ascender: number;
+  descender: number;
+  glyphs: Record<string, import('react').FC<import('react').SVGProps<SVGSVGElement>>>;
+  glyphData?: Record<string, TegakiGlyphData>;
+  glyphTimings: Record<string, number>;
+  registerFontFace: () => Promise<void>;
+}

package/index.js

@@ -1 +0,0 @@
-console.error("Package isn't ready yet. Please wait for the next release.");