@templatical/import-chamaileon 0.36.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026-present Templatical
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,38 @@
+# @templatical/import-chamaileon
+
+Convert Chamaileon email templates to Templatical format.
+
+Reads a Chamaileon persist document — the JSON `editorInstance.methods.getDocument()` returns — into a Templatical `TemplateContent` tree. Email JSON 2.0 through 4.1 is accepted after a key normalizer (kebab-case and camelCase styles, `{ reference, default }` colour variables). The input is that document, not `getEmailHtml()` / the HTML generator.
+
+## Install
+
+```sh
+npm install @templatical/import-chamaileon
+```
+
+## Usage
+
+```ts
+import { convertChamaileonTemplate } from "@templatical/import-chamaileon";
+
+const document = await editorInstance.methods.getDocument();
+const { content, report } = convertChamaileonTemplate(document);
+
+console.log(report.summary);
+console.log(report.warnings);
+```
+
+`convertChamaileonTemplate` also accepts the document serialized as a JSON string.
+
+Each entry in `report.entries` carries a `status`:
+
+- `converted` — mapped to a Templatical block with no loss of fidelity.
+- `approximated` — mapped to a Templatical block, but something had to be resolved or clamped (e.g. a nested multicolumn flattened, a 4+ column row folded to three, an outlined button, a loop whose children converted without their expression).
+- `html-fallback` — no Templatical block exists for this `type`; the raw node is preserved as JSON inside an `HtmlBlock`.
+- `skipped` — an empty loop or conditional; there were no children to convert.
+
+See [Migrating from Chamaileon](https://docs.templatical.com/guide/migration-from-chamaileon) for the full node-mapping table and what does not survive the conversion.
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,92 @@
+//#region src/types.d.ts
+/**
+ * Type definitions for the Chamaileon importer.
+ *
+ * The four report types are structurally identical to every other
+ * `@templatical/import-*` package's, so a caller can treat all importers
+ * uniformly. Changing a shape here without changing the others breaks that.
+ *
+ * The node type is loose on purpose. Email JSON 2.0.0 and 4.1.0 disagree on
+ * key names; a strict 4.1 interface would reject every 2.0 document. Mappers
+ * read through the helpers in `normalize.ts` / `attribute-parser.ts`.
+ */
+type ConversionStatus = "converted" | "approximated" | "html-fallback" | "skipped";
+interface ImportReportEntry {
+  /** The source Chamaileon `type` string (e.g. "fullwidth", "button", "typed-text"). */
+  sourceTag: string;
+  /** The Templatical block type produced, or null if skipped. */
+  templaticalBlockType: string | null;
+  status: ConversionStatus;
+  note?: string;
+}
+interface ImportReport {
+  entries: ImportReportEntry[];
+  warnings: string[];
+  summary: {
+    total: number;
+    converted: number;
+    approximated: number;
+    htmlFallback: number;
+    skipped: number;
+  };
+}
+interface ImportResult {
+  content: import("@templatical/types").TemplateContent;
+  report: ImportReport;
+}
+/** Document-level design token (`variables[]` in 4.x). */
+interface ChamaileonVariable {
+  name?: string;
+  value?: unknown;
+  type?: string;
+  reference?: string;
+  default?: unknown;
+}
+/**
+ * One node of a Chamaileon document tree.
+ *
+ * `type` discriminates. `style` keys are kebab-case in 2.0 and camelCase in
+ * 4.x; `attrs` holds content (`text`, `href`, `src`, `lineStyle`).
+ */
+interface ChamaileonNode {
+  eid?: string;
+  type?: string;
+  attrs?: Record<string, unknown>;
+  style?: Record<string, unknown>;
+  children?: ChamaileonNode[];
+  placeholder?: ChamaileonNode[];
+  customData?: unknown;
+  version?: string;
+  [key: string]: unknown;
+}
+/** The `getDocument()` object. */
+interface ChamaileonDocument {
+  body?: ChamaileonNode;
+  variables?: ChamaileonVariable[];
+  components?: unknown[];
+  title?: string;
+  previewText?: string;
+  subjectLine?: string;
+  fontFiles?: Record<string, string>;
+  [key: string]: unknown;
+}
+//#endregion
+//#region src/converter.d.ts
+/**
+ * Convert a Chamaileon `getDocument()` tree into a Templatical template.
+ *
+ * The input is the document object itself — `{ body, variables?, … }` —
+ * not `getEmailHtml()` markup and not an API envelope. That is documented
+ * rather than sniffed: guessing between the persist JSON and compiled HTML
+ * would send the HTML through the wrong package.
+ *
+ * @example
+ * ```ts
+ * const document = await editorInstance.methods.getDocument();
+ * const { content, report } = convertChamaileonTemplate(document);
+ * ```
+ */
+export declare function convertChamaileonTemplate(doc: ChamaileonDocument | string): ImportResult;
+//#endregion
+export type { ConversionStatus, ImportReport, ImportReportEntry, ImportResult };
+//# sourceMappingURL=index.d.ts.map