@threadlabs/looma 0.2.4 → 0.2.6

package/dist/loader.d.cts

@@ -0,0 +1,4 @@
+/** Compatibility loader for consumers that previously called the Stencil loader explicitly. */
+declare function defineCustomElements(): void;
+
+export { defineCustomElements };

package/dist/loader.d.ts

@@ -0,0 +1,4 @@
+/** Compatibility loader for consumers that previously called the Stencil loader explicitly. */
+declare function defineCustomElements(): void;
+
+export { defineCustomElements };

package/dist/loader.js

@@ -0,0 +1,16 @@
+import {
+  records,
+  styles
+} from "./chunk-3K45IWIJ.js";
+import {
+  registerLoomaPackage
+} from "./chunk-UHHA4WT5.js";
+import "./chunk-MLKGABMK.js";
+
+// src/loader.ts
+function defineCustomElements() {
+  registerLoomaPackage("core", records, styles);
+}
+export {
+  defineCustomElements
+};

package/dist/valibot.cjs

@@ -0,0 +1,31 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/field/valibot.ts
+var valibot_exports = {};
+__export(valibot_exports, {
+  valibotField: () => valibotField
+});
+module.exports = __toCommonJS(valibot_exports);
+function valibotField(schema, options = {}) {
+  return { ...options, schema };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  valibotField
+});

package/dist/valibot.d.cts

@@ -0,0 +1,10 @@
+import { GenericSchema, GenericSchemaAsync, InferOutput } from 'valibot';
+import { F as FieldValidation, f as FieldSchema } from './validation-bxcou-l-.cjs';
+
+/** Valibot's Standard Schema implementation preserves async transforms and issue paths.
+ * Type-only Valibot imports keep the adapter free of a schema-library runtime. */
+declare function valibotField<T extends GenericSchema | GenericSchemaAsync>(schema: T, options?: Omit<FieldValidation, 'schema'>): FieldValidation & {
+    schema: FieldSchema<InferOutput<T>>;
+};
+
+export { valibotField };

package/dist/valibot.d.ts

@@ -1,47 +1,5 @@
 import { GenericSchema, GenericSchemaAsync, InferOutput } from 'valibot';
-
-/** Structural Standard Schema v1 boundary; no schema-library runtime dependency. */
-interface FieldSchema<Output = unknown> {
-    readonly '~standard': {
-        readonly version: 1;
-        readonly vendor: string;
-        readonly validate: (value: unknown) => FieldSchemaResult<Output> | Promise<FieldSchemaResult<Output>>;
-        readonly types?: {
-            readonly input: unknown;
-            readonly output: Output;
-        };
-    };
-}
-interface FieldIssue {
-    readonly message: string;
-    readonly path?: ReadonlyArray<PropertyKey | {
-        readonly key: PropertyKey;
-    }>;
-    readonly severity?: 'error' | 'warning';
-}
-type FieldSchemaResult<T = unknown> = {
-    readonly value: T;
-    readonly issues?: undefined;
-} | {
-    readonly issues: readonly FieldIssue[];
-};
-interface FieldRequest<Context = unknown> {
-    raw: string;
-    value: string | null;
-    context: Context;
-    signal: AbortSignal;
-}
-interface FieldResult<Output = unknown> {
-    output?: Output;
-    issues: readonly FieldIssue[];
-}
-interface FieldValidation {
-    schema?: FieldSchema;
-    parse?: (raw: string, request: FieldRequest) => unknown | Promise<unknown>;
-    normalize?: (value: unknown, request: FieldRequest) => unknown | Promise<unknown>;
-    validator?: (value: unknown, request: FieldRequest) => Partial<FieldResult> | Promise<Partial<FieldResult>>;
-    issues?: readonly FieldIssue[];
-}
+import { F as FieldValidation, f as FieldSchema } from './validation-bxcou-l-.js';
 
 /** Valibot's Standard Schema implementation preserves async transforms and issue paths.
  * Type-only Valibot imports keep the adapter free of a schema-library runtime. */

package/dist/valibot.js

@@ -1,3 +1,5 @@
+import "./chunk-MLKGABMK.js";
+
 // src/field/valibot.ts
 function valibotField(schema, options = {}) {
   return { ...options, schema };

package/dist/{types/field/validation.d.ts → validation-bxcou-l-.d.cts}

@@ -1,5 +1,5 @@
 /** Structural Standard Schema v1 boundary; no schema-library runtime dependency. */
-export interface FieldSchema<Output = unknown> {
+interface FieldSchema<Output = unknown> {
     readonly '~standard': {
         readonly version: 1;
         readonly vendor: string;
@@ -10,47 +10,49 @@ export interface FieldSchema<Output = unknown> {
         };
     };
 }
-export interface FieldIssue {
+interface FieldIssue {
     readonly message: string;
     readonly path?: ReadonlyArray<PropertyKey | {
         readonly key: PropertyKey;
     }>;
     readonly severity?: 'error' | 'warning';
 }
-export type FieldSchemaResult<T = unknown> = {
+type FieldSchemaResult<T = unknown> = {
     readonly value: T;
     readonly issues?: undefined;
 } | {
     readonly issues: readonly FieldIssue[];
 };
-export interface FieldRequest<Context = unknown> {
+interface FieldRequest<Context = unknown> {
     raw: string;
     value: string | null;
     context: Context;
     signal: AbortSignal;
 }
-export interface FieldResult<Output = unknown> {
+interface FieldResult<Output = unknown> {
     output?: Output;
     issues: readonly FieldIssue[];
 }
-export interface FieldValidation {
+interface FieldValidation {
     schema?: FieldSchema;
     parse?: (raw: string, request: FieldRequest) => unknown | Promise<unknown>;
     normalize?: (value: unknown, request: FieldRequest) => unknown | Promise<unknown>;
     validator?: (value: unknown, request: FieldRequest) => Partial<FieldResult> | Promise<Partial<FieldResult>>;
     issues?: readonly FieldIssue[];
 }
-export interface FieldSelection {
+interface FieldSelection {
     start: number;
     end: number;
     direction?: 'forward' | 'backward' | 'none';
 }
-export interface FieldFormat {
+interface FieldFormat {
     display: string;
     selection: FieldSelection;
 }
-export type FieldFormatter = (raw: string, selection: FieldSelection) => FieldFormat | undefined;
+type FieldFormatter = (raw: string, selection: FieldSelection) => FieldFormat | undefined;
 /** Formatting is additive: every original character must survive in order.
  * Normalization belongs to submitted output, never the visible editing buffer. */
-export declare function formatEditingValue(raw: string, selection: FieldSelection, format?: FieldFormatter): FieldFormat;
-export declare function validateField(request: FieldRequest, config: FieldValidation): Promise<FieldResult>;
+declare function formatEditingValue(raw: string, selection: FieldSelection, format?: FieldFormatter): FieldFormat;
+declare function validateField(request: FieldRequest, config: FieldValidation): Promise<FieldResult>;
+
+export { type FieldValidation as F, type FieldFormatter as a, type FieldIssue as b, type FieldFormat as c, type FieldRequest as d, type FieldResult as e, type FieldSchema as f, type FieldSchemaResult as g, type FieldSelection as h, formatEditingValue as i, validateField as v };

package/dist/validation-bxcou-l-.d.ts

@@ -0,0 +1,58 @@
+/** Structural Standard Schema v1 boundary; no schema-library runtime dependency. */
+interface FieldSchema<Output = unknown> {
+    readonly '~standard': {
+        readonly version: 1;
+        readonly vendor: string;
+        readonly validate: (value: unknown) => FieldSchemaResult<Output> | Promise<FieldSchemaResult<Output>>;
+        readonly types?: {
+            readonly input: unknown;
+            readonly output: Output;
+        };
+    };
+}
+interface FieldIssue {
+    readonly message: string;
+    readonly path?: ReadonlyArray<PropertyKey | {
+        readonly key: PropertyKey;
+    }>;
+    readonly severity?: 'error' | 'warning';
+}
+type FieldSchemaResult<T = unknown> = {
+    readonly value: T;
+    readonly issues?: undefined;
+} | {
+    readonly issues: readonly FieldIssue[];
+};
+interface FieldRequest<Context = unknown> {
+    raw: string;
+    value: string | null;
+    context: Context;
+    signal: AbortSignal;
+}
+interface FieldResult<Output = unknown> {
+    output?: Output;
+    issues: readonly FieldIssue[];
+}
+interface FieldValidation {
+    schema?: FieldSchema;
+    parse?: (raw: string, request: FieldRequest) => unknown | Promise<unknown>;
+    normalize?: (value: unknown, request: FieldRequest) => unknown | Promise<unknown>;
+    validator?: (value: unknown, request: FieldRequest) => Partial<FieldResult> | Promise<Partial<FieldResult>>;
+    issues?: readonly FieldIssue[];
+}
+interface FieldSelection {
+    start: number;
+    end: number;
+    direction?: 'forward' | 'backward' | 'none';
+}
+interface FieldFormat {
+    display: string;
+    selection: FieldSelection;
+}
+type FieldFormatter = (raw: string, selection: FieldSelection) => FieldFormat | undefined;
+/** Formatting is additive: every original character must survive in order.
+ * Normalization belongs to submitted output, never the visible editing buffer. */
+declare function formatEditingValue(raw: string, selection: FieldSelection, format?: FieldFormatter): FieldFormat;
+declare function validateField(request: FieldRequest, config: FieldValidation): Promise<FieldResult>;
+
+export { type FieldValidation as F, type FieldFormatter as a, type FieldIssue as b, type FieldFormat as c, type FieldRequest as d, type FieldResult as e, type FieldSchema as f, type FieldSchemaResult as g, type FieldSelection as h, formatEditingValue as i, validateField as v };

package/editor/{chunk-B5WVJOPV.js → chunk-BXICJBWS.js}

@@ -1,8 +1,6 @@
 import {
-  TABLE_CELL_BACKGROUND_PRESETS,
-  filterLoomaMentionItems,
-  normalizeMentionResultLimit
-} from "./chunk-ZOUKEZ77.js";
+  TABLE_CELL_BACKGROUND_PRESETS
+} from "./chunk-JK53ENSG.js";
 
 // src/extensions/callout.ts
 import { mergeAttributes, Node } from "@tiptap/core";
@@ -54,7 +52,7 @@ var LoomaCallout = Node.create({
 });
 
 // src/extensions/preset.ts
-import { Extension as Extension7 } from "@tiptap/core";
+import { Extension as Extension8 } from "@tiptap/core";
 
 // ../../node_modules/.pnpm/@tiptap+extension-document@2.27.2_@tiptap+core@2.27.2_@tiptap+pm@2.27.2_/node_modules/@tiptap/extension-document/dist/index.js
 import { Node as Node2 } from "@tiptap/core";
@@ -5377,6 +5375,24 @@ var Mention = Node17.create({
 
 // src/extensions/mention.ts
 import { PluginKey as PluginKey7 } from "@tiptap/pm/state";
+
+// src/mention-contract.ts
+var DEFAULT_MENTION_RESULT_LIMIT = 8;
+var MAX_MENTION_RESULT_LIMIT = 20;
+function normalizeMentionResultLimit(limit = DEFAULT_MENTION_RESULT_LIMIT) {
+  if (!Number.isFinite(limit)) return DEFAULT_MENTION_RESULT_LIMIT;
+  return Math.min(MAX_MENTION_RESULT_LIMIT, Math.max(1, Math.trunc(limit)));
+}
+function filterLoomaMentionItems(items, query, limit = DEFAULT_MENTION_RESULT_LIMIT) {
+  const normalized = query.trim().toLocaleLowerCase();
+  const boundedLimit = normalizeMentionResultLimit(limit);
+  return items.filter((item) => {
+    if (!normalized) return true;
+    return item.label.toLocaleLowerCase().includes(normalized) || item.detail?.toLocaleLowerCase().includes(normalized);
+  }).slice(0, boundedLimit);
+}
+
+// src/extensions/mention.ts
 var EMPTY_STATE = {
   active: false,
   items: [],
@@ -5555,6 +5571,94 @@ function createLoomaMentionExtension(options = {}) {
   });
 }
 
+// src/extensions/smart-paste.ts
+import { Extension as Extension7 } from "@tiptap/core";
+import { DOMParser as ProseMirrorDOMParser } from "@tiptap/pm/model";
+import { Plugin as Plugin6 } from "@tiptap/pm/state";
+import MarkdownIt from "markdown-it";
+var DOCUMENT_MARKUP_MODES = /* @__PURE__ */ new Set(["html", "markdown", "md", "mdx"]);
+var MARKDOWN_MODES = /* @__PURE__ */ new Set(["markdown", "md", "mdx"]);
+var DOCUMENT_HTML_PATTERN = /<(?:html|body|main|article|section|header|footer|h[1-6]|p|ul|ol|li|blockquote|table|thead|tbody|tfoot|tr|th|td|figure|figcaption|img|hr|aside)\b/i;
+var MARKDOWN_STRUCTURE_PATTERN = /(?:^|\n)(?:#{1,6}\s+|>\s+|(?:[-+*]|\d+\.)\s+|```|~~~)|!\[[^\]]*]\([^)]*\)|\[[^\]]+]\([^)]*\)/;
+var UNSAFE_HTML_SELECTOR = "script, style, noscript, iframe, object, embed, template";
+var markdown = new MarkdownIt({
+  html: false,
+  linkify: true,
+  typographer: false
+});
+function sourceEditorMode(event) {
+  const metadata = event.clipboardData?.getData("vscode-editor-data");
+  if (!metadata) return null;
+  try {
+    const value = JSON.parse(metadata);
+    return typeof value.mode === "string" ? value.mode.toLowerCase() : null;
+  } catch {
+    return null;
+  }
+}
+function selectionIsInsideCodeBlock(parentTypeName) {
+  return parentTypeName === "codeBlock";
+}
+function looksLikeDocumentHtml(value) {
+  return /<!doctype\s+html/i.test(value) || DOCUMENT_HTML_PATTERN.test(value);
+}
+function looksLikeMarkdown(value) {
+  return MARKDOWN_STRUCTURE_PATTERN.test(value);
+}
+function parseHtmlSlice(schema, value) {
+  const parsed = new globalThis.DOMParser().parseFromString(value, "text/html");
+  parsed.querySelectorAll(UNSAFE_HTML_SELECTOR).forEach((element) => element.remove());
+  const container = document.createElement("div");
+  container.append(...Array.from(parsed.body.childNodes, (node) => node.cloneNode(true)));
+  if (!container.textContent?.trim() && !container.querySelector("img, hr")) return null;
+  return ProseMirrorDOMParser.fromSchema(schema).parseSlice(container, {
+    preserveWhitespace: false
+  });
+}
+function documentSlice(schema, plainText, richHtml, mode) {
+  if (mode && MARKDOWN_MODES.has(mode)) {
+    return parseHtmlSlice(schema, markdown.render(plainText));
+  }
+  if (mode === "html") {
+    return parseHtmlSlice(schema, plainText);
+  }
+  if (!mode && !richHtml && looksLikeDocumentHtml(plainText)) {
+    return parseHtmlSlice(schema, plainText);
+  }
+  if (!mode && !richHtml && looksLikeMarkdown(plainText)) {
+    return parseHtmlSlice(schema, markdown.render(plainText));
+  }
+  return null;
+}
+var LoomaSmartPaste = Extension7.create({
+  name: "loomaSmartPaste",
+  priority: 1100,
+  addProseMirrorPlugins() {
+    return [
+      new Plugin6({
+        props: {
+          handlePaste: (view, event) => {
+            if (!event.clipboardData) return false;
+            if (selectionIsInsideCodeBlock(view.state.selection.$from.parent.type.name)) {
+              return false;
+            }
+            const plainText = event.clipboardData.getData("text/plain");
+            if (!plainText.trim()) return false;
+            const richHtml = event.clipboardData.getData("text/html");
+            const mode = sourceEditorMode(event);
+            if (mode && !DOCUMENT_MARKUP_MODES.has(mode)) return false;
+            const slice = documentSlice(view.state.schema, plainText, richHtml, mode);
+            if (!slice) return false;
+            const transaction = view.state.tr.replaceSelection(slice).scrollIntoView().setMeta("paste", true).setMeta("uiEvent", "paste");
+            view.dispatch(transaction);
+            return true;
+          }
+        }
+      })
+    ];
+  }
+});
+
 // ../../node_modules/.pnpm/@tiptap+extension-table@2.27.2_@tiptap+core@2.27.2_@tiptap+pm@2.27.2__@tiptap+pm@2.27.2/node_modules/@tiptap/extension-table/dist/index.js
 import { findParentNodeClosestToPos, Node as Node18, mergeAttributes as mergeAttributes23, callOrReturn as callOrReturn2, getExtensionField as getExtensionField2 } from "@tiptap/core";
 import { TextSelection as TextSelection3 } from "@tiptap/pm/state";
@@ -6082,7 +6186,7 @@ function setActiveTableCellBackground(editor, backgroundColor) {
 
 // src/extensions/preset.ts
 var lowlight = createLowlight(common);
-var LoomaTableKit = Extension7.create({
+var LoomaTableKit = Extension8.create({
   name: "loomaTableKit",
   addExtensions() {
     return [LoomaTable, TableRow, LoomaTableHeader, LoomaTableCell];
@@ -6126,6 +6230,7 @@ function getDefaultEditorExtensions(options = {}) {
     Image.configure({ inline: imageInline }),
     Highlight.configure({ multicolor: false }),
     Code,
+    LoomaSmartPaste,
     CodeBlockLowlight.configure({ lowlight }),
     Typography,
     Placeholder.configure({
@@ -6448,7 +6553,7 @@ function handleTableOverlayAction(editor, detail) {
 }
 
 // src/extensions/slash-command.ts
-import { Extension as Extension8 } from "@tiptap/core";
+import { Extension as Extension9 } from "@tiptap/core";
 var CALLOUT_COMMANDS = [
   {
     title: "Info",
@@ -6593,7 +6698,7 @@ var EMPTY_STATE2 = {
   rect: null,
   select: null
 };
-var LoomaSlashCommand = Extension8.create({
+var LoomaSlashCommand = Extension9.create({
   name: "loomaSlashCommand",
   addOptions() {
     return {
@@ -6692,8 +6797,13 @@ function createLoomaSlashCommandExtension(options = {}) {
 export {
   LOOMA_CALLOUT_TONES,
   LoomaCallout,
+  DEFAULT_MENTION_RESULT_LIMIT,
+  MAX_MENTION_RESULT_LIMIT,
+  normalizeMentionResultLimit,
+  filterLoomaMentionItems,
   LoomaMentionSuggestionPluginKey,
   createLoomaMentionExtension,
+  LoomaSmartPaste,
   LoomaTable,
   LoomaTableHeader,
   LoomaTableCell,

package/editor/{chunk-ZOUKEZ77.js → chunk-JK53ENSG.js}

@@ -1,3 +1,9 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
 // src/table-backgrounds.ts
 var TABLE_CELL_BACKGROUND_PRESETS = {
   none: null,
@@ -16,27 +22,8 @@ var TABLE_CELL_BACKGROUND_OPTIONS = [
   { action: "background-red", label: "Red", value: TABLE_CELL_BACKGROUND_PRESETS.red, swatch: TABLE_CELL_BACKGROUND_PRESETS.red }
 ];
 
-// src/mention-contract.ts
-var DEFAULT_MENTION_RESULT_LIMIT = 8;
-var MAX_MENTION_RESULT_LIMIT = 20;
-function normalizeMentionResultLimit(limit = DEFAULT_MENTION_RESULT_LIMIT) {
-  if (!Number.isFinite(limit)) return DEFAULT_MENTION_RESULT_LIMIT;
-  return Math.min(MAX_MENTION_RESULT_LIMIT, Math.max(1, Math.trunc(limit)));
-}
-function filterLoomaMentionItems(items, query, limit = DEFAULT_MENTION_RESULT_LIMIT) {
-  const normalized = query.trim().toLocaleLowerCase();
-  const boundedLimit = normalizeMentionResultLimit(limit);
-  return items.filter((item) => {
-    if (!normalized) return true;
-    return item.label.toLocaleLowerCase().includes(normalized) || item.detail?.toLocaleLowerCase().includes(normalized);
-  }).slice(0, boundedLimit);
-}
-
 export {
+  __export,
   TABLE_CELL_BACKGROUND_PRESETS,
-  TABLE_CELL_BACKGROUND_OPTIONS,
-  DEFAULT_MENTION_RESULT_LIMIT,
-  MAX_MENTION_RESULT_LIMIT,
-  normalizeMentionResultLimit,
-  filterLoomaMentionItems
+  TABLE_CELL_BACKGROUND_OPTIONS
 };