@inpageedit/core 0.3.2 → 0.4.0

package/dist/plugins/BasePlugin.d.ts

@@ -14,6 +14,6 @@ export default class BasePlugin<T extends unknown = any> {
     protected removeDisposeHandler(fn: DisposeHandler): void;
     set name(name: string);
     get name(): string;
-    get logger(): import('cordis').Logger;
+    get logger(): import('../InPageEdit').Logger;
 }
 export {};

package/dist/services/SsiModalService.d.ts

@@ -29,6 +29,7 @@ export declare class SsiModalService {
     private modal?;
     constructor(ctx: InPageEdit);
     protected start(): void | Promise<void>;
+    get logger(): import('../InPageEdit').Logger;
     protected stop(): void | Promise<void>;
     hackSsiModal(ssiModalLib: LibSsiModal): SsiModal.ssi_modal;
 }

package/dist/utils/Logger.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Browser Logger — tiny extensible logger for the browser.
+ *
+ * Goals:
+ * - Support `new Logger({...})` AND callable instances: `logger('group', opts?)`.
+ * - Log levels with threshold filtering; per-call override via `{ print: true }`.
+ * - Prefix (app name) and nested groups with colorized labels (CSS `%c`).
+ * - Deterministic colors per label; overrideable, last-set wins.
+ * - Custom levels (e.g., success, debug) with `logger.defineLevel(...)`.
+ * - Extensible via lightweight hooks.
+ *
+ * Usage:
+ *   const logger = new Logger({ level: 2, name: 'MyApp', color: 'green' });
+ *   logger.info('message', { any: 'value' });
+ *   const group = logger('group', { color: 'blue' });
+ *   group.warn('message');
+ *   logger.defineLevel('success', { rank: 1, label: 'S', method: 'info' });
+ *   logger.success('Saved!', { id: 123 }, { print: true });
+ */
+export type ConsoleMethod = 'log' | 'info' | 'warn' | 'error';
+export interface LevelDef {
+    /** Severity rank. Lower = less severe. Only messages with rank >= logger.level print, unless per-call {print:true}. */
+    rank: number;
+    /** Badge shown like [I], [W]. */
+    label?: string;
+    /** console method used for emission. */
+    method?: ConsoleMethod;
+}
+export declare enum LoggerLevel {
+    debug = -1,
+    log = 0,
+    info = 1,
+    warn = 2,
+    error = 3,
+    silent = 4
+}
+export interface LoggerOptions {
+    /** Minimum severity to print: 0 log, 1 info, 2 warn, 3 error. */
+    level?: LoggerLevel | number;
+    /** App prefix. Can be empty string to omit. */
+    name?: string;
+    /** CSS color for the prefix. If omitted, deterministic color will be chosen. */
+    color?: string;
+    /** Quick on/off switch. */
+    enabled?: boolean;
+    /** Optional custom levels at construction time. */
+    levels?: Record<string, LevelDef>;
+}
+export interface GroupOptions {
+    /** CSS color for the group label. */
+    color?: string;
+}
+export interface LogCallOptions {
+    /** Force printing this call even if below the threshold. */
+    print?: boolean;
+}
+export interface Hooks {
+    /** Called right before emitting. Return false to cancel. */
+    beforeEmit?: (payload: EmitPayload) => boolean | void;
+    /** Called after a successful emit. */
+    afterEmit?: (payload: EmitPayload) => void;
+}
+export interface EmitPayload {
+    level: string;
+    rank: number;
+    method: ConsoleMethod;
+    prefix?: string;
+    groupPath: string[];
+    args: unknown[];
+    enabled: boolean;
+    willPrint: boolean;
+}
+export interface LoggerInstance {
+    readonly isLogger: true;
+    /** Current threshold. Set like: logger.level = 2 */
+    level: number;
+    /** Toggle output. */
+    enabled: boolean;
+    /** Prefix name (app). */
+    name?: string;
+    /** Explicit prefix color. */
+    color?: string;
+    log: (...args: unknown[]) => void;
+    info: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+    /** Emit at a specific level name. */
+    at: (levelName: string, ...args: unknown[]) => void;
+    /** Define or override a level and create a convenience method. */
+    defineLevel: (name: string, def: LevelDef) => void;
+    /** Return a child logger under a group (also available via calling the instance). */
+    group: (label: string, opts?: GroupOptions) => Logger;
+    /** Register hooks. Any missing callbacks keep their previous values. */
+    setHooks: (hooks: Hooks) => void;
+    /** Assign or override colors for labels (prefix/groups). */
+    setLabelColor: (label: string, color: string) => void;
+}
+export interface LoggerCallable {
+    (label: string, opts?: GroupOptions): Logger;
+}
+export type Logger = LoggerInstance & LoggerCallable;
+export declare const Logger: {
+    new (opts?: LoggerOptions): Logger;
+    /** Helper factory without `new` */
+    create: (opts?: LoggerOptions) => Logger;
+};

package/dist/utils/vueHooks.d.ts

@@ -2,4 +2,4 @@ import { InPageEdit } from '../InPageEdit';
 import { App } from 'vue';
 export declare const IPEInjectKey: unique symbol;
 export declare const injectIPE: (ipe: InPageEdit, app?: App) => InPageEdit;
-export declare const useIPE: () => InPageEdit | undefined;
+export declare const useIPE: () => InPageEdit;