@eriknaslund/skiss 0.2.1 → 0.3.0

package/dist/index.d.ts

@@ -63,8 +63,12 @@ interface ClassNode {
     line: number;
 }
 type Severity = 'error' | 'warning';
-/** Codes from the table in docs/ARCHITECTURE.md. `parse` adds the `E_` codes, `resolve` the `W_` codes. */
-type DiagnosticCode = 'E_UNPARSABLE' | 'E_FIELD_WITHOUT_CLASS' | 'E_MISSING_TYPE' | 'E_UNCLOSED_MANY' | 'E_BAD_NAME' | 'W_UNKNOWN_TYPE' | 'W_UNDECLARED_CLASS' | 'W_UNDECLARED_FIELD' | 'W_DUPLICATE_CLASS' | 'W_DUPLICATE_FIELD' | 'W_MULTIPLE_IDENTIFIERS';
+/**
+ * Codes from the tables in docs/ARCHITECTURE.md. `parse` adds the `E_` codes,
+ * `resolve` the `W_` codes, and `importLinkML` the one code of its own,
+ * `E_NOT_YAML`, for a text no schema can be read out of.
+ */
+type DiagnosticCode = 'E_UNPARSABLE' | 'E_FIELD_WITHOUT_CLASS' | 'E_MISSING_TYPE' | 'E_UNCLOSED_MANY' | 'E_BAD_NAME' | 'W_UNKNOWN_TYPE' | 'W_UNDECLARED_CLASS' | 'W_UNDECLARED_FIELD' | 'W_DUPLICATE_CLASS' | 'W_DUPLICATE_FIELD' | 'W_MULTIPLE_IDENTIFIERS' | 'E_NOT_YAML';
 interface Diagnostic {
     severity: Severity;
     code: DiagnosticCode;
@@ -168,6 +172,41 @@ declare function compile(source: string, opts: CompileOptions): CompileResult;
  */
 declare function formatDiagnostic(d: Diagnostic, file?: string): string;
 
+/**
+ * One thing the projection could not carry. `kind` is the LinkML key, or one
+ * of the projection's own kinds: `renamed`, `narrowed`, `inlined`,
+ * `enum_detail`, `annotation`, `schema`. `element` names what carried it as
+ * the sketch names it — `Class`, `Class.field` — or, for an enum, its LinkML
+ * name, which the sketch does not keep.
+ */
+interface Dropped {
+    kind: string;
+    element: string;
+    detail?: string;
+}
+interface FromLinkMLResult {
+    /** The projected sketch, parsed from `source`, so every node has a position. */
+    document: Document;
+    /** The sketch as canonical Skiss text. */
+    source: string;
+    /** SPEC §8, in schema order: class by class, then enums, then the schema itself. */
+    dropped: Dropped[];
+}
+declare function fromLinkML(schema: unknown): FromLinkMLResult;
+declare function formatDropped(dropped: Dropped[]): string;
+
+declare function toSkiss(doc: Document): string;
+
+interface ImportResult {
+    /** The projected sketch as canonical Skiss text, `\n`-terminated. */
+    output: string;
+    /** SPEC §8, in schema order: what the projection could not carry. */
+    dropped: Dropped[];
+    /** The diagnostics of the projected sketch. Their lines are lines of `output`. */
+    diagnostics: Diagnostic[];
+}
+declare function importLinkML(text: string): ImportResult;
+
 declare function parse(source: string): Document;
 
 /** What `resolve` returns: a `Document` whose `undeclared` list is always present. */
@@ -176,6 +215,6 @@ interface ResolvedDocument extends Document {
 }
 declare function resolve(doc: Document): ResolvedDocument;
 
-declare const VERSION = "0.2.1";
+declare const VERSION = "0.3.0";
 
-export { type ClassNode, type CompileOptions, type CompileResult, type Diagnostic, type DiagnosticCode, type Document, type FieldNode, type JoinRef, type LinkMLAnnotations, type LinkMLAttribute, type LinkMLClass, type LinkMLCompileOptions, type LinkMLEnum, type LinkMLOptions, type LinkMLSchema, type MermaidCompileOptions, type MermaidOptions, type Name, type Primitive, type ResolvedDocument, type SerializeFormat, type Severity, type TypeRef, VERSION, compile, formatDiagnostic, parse, resolve, serialize, toLinkML, toMermaid };
+export { type ClassNode, type CompileOptions, type CompileResult, type Diagnostic, type DiagnosticCode, type Document, type Dropped, type FieldNode, type FromLinkMLResult, type ImportResult, type JoinRef, type LinkMLAnnotations, type LinkMLAttribute, type LinkMLClass, type LinkMLCompileOptions, type LinkMLEnum, type LinkMLOptions, type LinkMLSchema, type MermaidCompileOptions, type MermaidOptions, type Name, type Primitive, type ResolvedDocument, type SerializeFormat, type Severity, type TypeRef, VERSION, compile, formatDiagnostic, formatDropped, fromLinkML, importLinkML, parse, resolve, serialize, toLinkML, toMermaid, toSkiss };

package/dist/index.js

@@ -520,9 +520,9 @@ function resolve(doc) {
       }
     }
   }
-  const present = new Set(out.diagnostics.map(key));
+  const present2 = new Set(out.diagnostics.map(key));
   for (const w of warnings) {
-    if (!present.has(key(w))) out.diagnostics.push(w);
+    if (!present2.has(key(w))) out.diagnostics.push(w);
   }
   out.diagnostics.sort((a, b) => a.line - b.line);
   out.undeclared = [...undeclared.values()].map((n) => ({ ...n }));
@@ -908,16 +908,521 @@ function formatDiagnostic(d, file) {
   return `${where}: ${d.severity} ${d.code} ${d.message}`;
 }
 
+// src/generators/skiss.ts
+var TRAILER_COLUMN = 40;
+function toSkiss(doc) {
+  if (doc.classes.length === 0) return "";
+  return `${doc.classes.map(classBlock).join("\n\n")}
+`;
+}
+function classBlock(cls) {
+  const head = cls.name.text + (cls.system === void 0 ? "" : ` @${cls.system.text}`) + (cls.similarTo === void 0 ? "" : ` ~ ${cls.similarTo.text}`);
+  return [withTrailer(head, cls), ...cls.fields.map(fieldLine)].join("\n");
+}
+function fieldLine(field) {
+  const type = typeText2(field.type);
+  const head = `  ${field.name.text}` + (field.identifier ? "*" : "") + (type === void 0 ? "" : `: ${type}`) + (field.system === void 0 ? "" : ` @${field.system.text}`) + (field.joinsTo === void 0 ? "" : ` = ${field.joinsTo.className.text}.${field.joinsTo.fieldName.text}`);
+  return withTrailer(head, field);
+}
+function typeText2(type) {
+  if (type === void 0) return void 0;
+  let text;
+  switch (type.kind) {
+    case "primitive":
+      if (type.name === "string" && !type.many) return void 0;
+      text = type.name;
+      break;
+    case "class":
+    case "unknown":
+      text = type.name.text;
+      break;
+    case "enum":
+      text = type.values.map((v) => v.text).join("|");
+      break;
+  }
+  return type.many ? `${text}[]` : text;
+}
+function withTrailer(head, node) {
+  const parts2 = [];
+  if (node.description !== void 0 && node.description !== "")
+    parts2.push(`# ${node.description}`);
+  if (node.note !== void 0 && node.note !== "") parts2.push(`? ${node.note}`);
+  if (parts2.length === 0) return head;
+  const gap = head.length < TRAILER_COLUMN - 1 ? " ".repeat(TRAILER_COLUMN - head.length) : "  ";
+  return head + gap + parts2.join(" ");
+}
+
+// src/generators/from-linkml.ts
+var PRIMITIVE_RANGE = {
+  string: "string",
+  integer: "int",
+  float: "float",
+  double: "float",
+  decimal: "float",
+  boolean: "bool",
+  date: "date",
+  datetime: "datetime",
+  uri: "uri",
+  uriorcurie: "uri"
+};
+var CLASS_KEYS = /* @__PURE__ */ new Set(["description", "annotations", "close_mappings", "attributes", "slots"]);
+var SLOT_KEYS = /* @__PURE__ */ new Set(["description", "annotations", "range", "multivalued", "identifier"]);
+var CLASS_TAGS = /* @__PURE__ */ new Set(["system", "note", "undeclared"]);
+var SLOT_TAGS = /* @__PURE__ */ new Set(["system", "note", "joins_to"]);
+var QUIET_SCHEMA_KEYS = /* @__PURE__ */ new Set([
+  "id",
+  "name",
+  "prefixes",
+  "imports",
+  "default_prefix",
+  "default_range",
+  "title",
+  "license",
+  "version",
+  "classes",
+  "slots",
+  "enums"
+]);
+var UNKNOWN_TYPE = /^[a-z][a-z0-9_-]*$/;
+function fromLinkML(schema) {
+  const root = asRecord(schema);
+  if (root === void 0) return nothing("schema", "the schema is not an object");
+  const schemaName = schemaElement(root);
+  const classBlock2 = asRecord(get(root, "classes"));
+  if (classBlock2 === void 0) return nothing(schemaName, "the schema has no `classes`");
+  const classDefs = classBlock2;
+  const dropped = [];
+  const report = (kind, element, detail) => {
+    dropped.push(detail === void 0 ? { kind, element } : { kind, element, detail });
+  };
+  const slotDefs = asRecord(get(root, "slots")) ?? {};
+  const enumDefs = asRecord(get(root, "enums")) ?? {};
+  const defaultRange = stringOf(get(root, "default_range")) ?? "string";
+  const classNames = /* @__PURE__ */ new Map();
+  const takenClasses = /* @__PURE__ */ new Set();
+  for (const key2 of Object.keys(classDefs)) {
+    classNames.set(key2, unique(toClassName(key2), takenClasses));
+  }
+  const fieldNames = /* @__PURE__ */ new Map();
+  for (const key2 of Object.keys(classDefs)) {
+    const names = /* @__PURE__ */ new Map();
+    const taken = /* @__PURE__ */ new Set();
+    for (const slot of slotKeysOf(asRecord(get(classDefs, key2)) ?? {})) {
+      names.set(slot, unique(toFieldName(slot), taken));
+    }
+    fieldNames.set(key2, names);
+  }
+  const referenced = /* @__PURE__ */ new Set();
+  const reference = (element, from, to) => {
+    if (from === to || referenced.has(`${element}\0${to}`)) return;
+    referenced.add(`${element}\0${to}`);
+    report("renamed", element, `\`${to}\` from \`${from}\``);
+  };
+  const classNameOf = (key2) => classNames.get(key2) ?? toClassName(key2);
+  const fieldNameOf = (classKey, slot) => fieldNames.get(classKey)?.get(slot) ?? toFieldName(slot);
+  const enumValues = /* @__PURE__ */ new Map();
+  const unwritable = /* @__PURE__ */ new Map();
+  for (const key2 of Object.keys(enumDefs)) {
+    const rawValues = get(asRecord(get(enumDefs, key2)) ?? {}, "permissible_values");
+    const values = asRecord(rawValues);
+    const keys = Object.keys(values ?? {});
+    const bad = keys.find((value) => !SYSTEM_OR_VALUE.test(value));
+    if (values === void 0 && present(rawValues)) {
+      unwritable.set(key2, `${shown(rawValues)} is not a map of permissible values`);
+    } else if (keys.length < 2) {
+      const count = `${keys.length} permissible value${keys.length === 1 ? "" : "s"}`;
+      unwritable.set(key2, `${count} cannot be an inline enum (\xA73.4)`);
+    } else if (bad !== void 0) {
+      unwritable.set(key2, `\`${bad}\` is not a value Skiss can write (\xA74)`);
+    } else {
+      enumValues.set(key2, keys);
+    }
+  }
+  const enumUses = [];
+  const classes = [];
+  for (const key2 of Object.keys(classDefs)) {
+    const raw = get(classDefs, key2);
+    const body = asRecord(raw);
+    const name2 = classNameOf(key2);
+    if (body === void 0 && raw !== null && raw !== void 0) {
+      report("class", name2, "is not a class definition");
+      continue;
+    }
+    const def = body ?? {};
+    if (name2 !== key2) report("renamed", name2, `from \`${key2}\``);
+    const annotations = annotationsOf(def);
+    if (annotations.get("undeclared") === true) {
+      for (const other of Object.keys(def)) {
+        if (other !== "annotations") report(other, name2);
+      }
+      continue;
+    }
+    const node = { name: at0(name2), fields: [], line: 0 };
+    const description = oneLine(stringOf(get(def, "description")));
+    if (description !== void 0) node.description = description;
+    const system = annotations.get("system");
+    if (typeof system === "string" && SYSTEM_OR_VALUE.test(system)) node.system = at0(system);
+    else if (system !== void 0) report("annotation", name2, "`system` is not a system name");
+    const note = oneLine(stringOf(annotations.get("note")));
+    if (note !== void 0) node.note = note;
+    const mappings = stringList(get(def, "close_mappings"));
+    const first = mappings[0];
+    const target = first === void 0 ? "" : localName(first);
+    if (target !== "") {
+      const similar = Object.hasOwn(classDefs, target) ? classNameOf(target) : toClassName(target);
+      node.similarTo = at0(similar);
+      reference(name2, target, similar);
+    }
+    for (const other of Object.keys(def)) {
+      if (CLASS_KEYS.has(other)) {
+        if (other === "annotations") {
+          for (const tag of annotations.keys()) {
+            if (!CLASS_TAGS.has(tag)) report("annotation", name2, `\`${tag}\``);
+          }
+        }
+        if (other === "close_mappings") {
+          if (target === "") report("close_mappings", name2, "no mapping this can read");
+          else if (mappings.length > 1) {
+            report("close_mappings", name2, `${mappings.length - 1} beyond the first`);
+          }
+        }
+        const block = get(def, other);
+        if (other === "attributes" && present(block) && asRecord(block) === void 0) {
+          report("attributes", name2, `${shown(block)} is not a map`);
+        }
+        if (other === "slots" && present(block) && !Array.isArray(block)) {
+          report("slots", name2, `${shown(block)} is not a list`);
+        }
+        continue;
+      }
+      if (other === "slot_usage") {
+        const usage = asRecord(get(def, other));
+        if (usage === void 0) {
+          report("slot_usage", name2);
+          continue;
+        }
+        for (const slot of Object.keys(usage)) {
+          if (fieldNames.get(key2)?.has(slot) === true) {
+            report("slot_usage", `${name2}.${fieldNameOf(key2, slot)}`);
+          } else {
+            report("slot_usage", name2, `\`${slot}\` is inherited and not in the sketch`);
+          }
+        }
+        continue;
+      }
+      report(other, name2);
+    }
+    for (const slot of slotKeysOf(def)) {
+      const attributes = asRecord(get(def, "attributes")) ?? {};
+      const rawSlot = Object.hasOwn(attributes, slot) ? get(attributes, slot) : get(slotDefs, slot);
+      const slotDef = asRecord(rawSlot);
+      if (slotDef === void 0 && present(rawSlot)) {
+        report("slot", `${name2}.${fieldNameOf(key2, slot)}`, "is not a slot definition");
+        continue;
+      }
+      node.fields.push(buildField(key2, name2, slot, slotDef ?? {}));
+    }
+    classes.push(node);
+  }
+  for (const key2 of Object.keys(enumDefs)) {
+    const def = asRecord(get(enumDefs, key2)) ?? {};
+    const uses = enumUses.filter((use) => use.enumName === key2);
+    const why = unwritable.get(key2);
+    if (why !== void 0) report("enum", key2, `${why}; those attributes keep no type`);
+    else if (uses.length === 0) report("unused_enum", key2, "no attribute has it as its range");
+    else if (uses.length > 1 && sharingLost(uses, enumUses)) {
+      report("inlined", key2, `inlined at ${uses.length} attributes`);
+    }
+    const detail = [];
+    const values = asRecord(get(def, "permissible_values")) ?? {};
+    const detailed = Object.keys(values).filter((value) => {
+      const valueBody = asRecord(get(values, value));
+      return valueBody !== void 0 && Object.keys(valueBody).length > 0;
+    });
+    if (detailed.length > 0) {
+      const bodies = detailed.length === 1 ? "carries a body of its own" : "carry bodies of their own";
+      detail.push(`${list(detailed)} ${bodies}`);
+    }
+    const others = Object.keys(def).filter((other) => other !== "permissible_values");
+    if (others.length > 0) detail.push(`the enum carries ${list(others)}`);
+    if (detail.length > 0) report("enum_detail", key2, detail.join("; "));
+  }
+  for (const slot of Object.keys(slotDefs)) {
+    if (!listedSomewhere(slot)) report("slot", slot, "no class lists it");
+  }
+  for (const key2 of Object.keys(root)) {
+    if (!QUIET_SCHEMA_KEYS.has(key2)) report("schema", schemaName, `\`${key2}\``);
+  }
+  const source = toSkiss({ classes, diagnostics: [] });
+  return { document: parse(source), source, dropped };
+  function buildField(classKey, className, slot, def) {
+    const name2 = fieldNameOf(classKey, slot);
+    const element = `${className}.${name2}`;
+    if (name2 !== slot) report("renamed", element, `from \`${slot}\``);
+    const identifier = get(def, "identifier");
+    if (present(identifier) && typeof identifier !== "boolean") {
+      report("identifier", element, `${shown(identifier)} is not a boolean`);
+    }
+    const field = {
+      name: at0(name2),
+      identifier: identifier === true,
+      line: 0
+    };
+    const description = oneLine(stringOf(get(def, "description")));
+    if (description !== void 0) field.description = description;
+    const type = typeFor(element, name2, def);
+    if (type !== void 0) field.type = type;
+    const annotations = annotationsOf(def);
+    const system = annotations.get("system");
+    if (typeof system === "string" && SYSTEM_OR_VALUE.test(system)) field.system = at0(system);
+    else if (system !== void 0) report("annotation", element, "`system` is not a system name");
+    const joins = annotations.get("joins_to");
+    if (typeof joins === "string") {
+      const dot = joins.indexOf(".");
+      const target = joins.slice(0, dot);
+      const targetField = joins.slice(dot + 1);
+      if (dot > 0 && targetField !== "") {
+        const targetClass = classNameOf(target);
+        const targetName = fieldNameOf(target, targetField);
+        field.joinsTo = { className: at0(targetClass), fieldName: at0(targetName) };
+        reference(element, target, targetClass);
+        reference(element, targetField, targetName);
+      } else report("annotation", element, "`joins_to` is not `Class.field`");
+    } else if (joins !== void 0) report("annotation", element, "`joins_to` is not text");
+    const note = oneLine(stringOf(annotations.get("note")));
+    if (note !== void 0) field.note = note;
+    for (const other of Object.keys(def)) {
+      if (!SLOT_KEYS.has(other)) {
+        report(other, element);
+        continue;
+      }
+      if (other !== "annotations") continue;
+      for (const tag of annotations.keys()) {
+        if (!SLOT_TAGS.has(tag)) report("annotation", element, `\`${tag}\``);
+      }
+    }
+    return field;
+  }
+  function typeFor(element, field, def) {
+    const rawMany = get(def, "multivalued");
+    if (present(rawMany) && typeof rawMany !== "boolean") {
+      report("multivalued", element, `${shown(rawMany)} is not a boolean`);
+    }
+    const many = rawMany === true;
+    const rawRange = get(def, "range");
+    if (present(rawRange) && typeof rawRange !== "string") {
+      report("range", element, `${shown(rawRange)} is not a string`);
+    } else if (rawRange === "") report("range", element, "the range is empty");
+    const range = stringOf(rawRange) ?? defaultRange;
+    if (Object.hasOwn(classDefs, range)) {
+      const target = classNameOf(range);
+      reference(element, range, target);
+      return { kind: "class", name: at0(target), many };
+    }
+    if (Object.hasOwn(enumDefs, range)) {
+      const values = enumValues.get(range);
+      if (values === void 0) return many ? stringType(true) : void 0;
+      enumUses.push({ enumName: range, field, values: values.join("|") });
+      return { kind: "enum", values: values.map(at0), many };
+    }
+    if (Object.hasOwn(PRIMITIVE_RANGE, range)) {
+      const primitive = PRIMITIVE_RANGE[range] ?? "string";
+      if (primitive === "string") return many ? stringType(true) : void 0;
+      return { kind: "primitive", name: primitive, written: at0(primitive), many };
+    }
+    if (/^[A-Z]/.test(range)) {
+      const target = toClassName(range);
+      reference(element, range, target);
+      return { kind: "class", name: at0(target), many };
+    }
+    const word = range.toLowerCase();
+    if (!UNKNOWN_TYPE.test(word)) {
+      report("narrowed", element, `\`${range}\` is not a type Skiss can write; it reads as string`);
+      return many ? stringType(true) : void 0;
+    }
+    report("narrowed", element, `\`${range}\` is not a Skiss type; it falls back to string`);
+    return { kind: "unknown", name: at0(word), many };
+  }
+  function listedSomewhere(slot) {
+    for (const key2 of Object.keys(classDefs)) {
+      const def = asRecord(get(classDefs, key2)) ?? {};
+      if (stringList(get(def, "slots")).includes(slot)) return true;
+    }
+    return false;
+  }
+}
+function sharingLost(uses, all) {
+  const first = uses[0];
+  if (first === void 0) return false;
+  if (uses.some((use) => use.field !== first.field)) return true;
+  return all.some((use) => use.field === first.field && use.values !== first.values);
+}
+var COUNTED = {
+  renamed: ["name", "names"],
+  inlined: ["enum", "enums"],
+  enum: ["unwritable enum", "unwritable enums"],
+  unused_enum: ["unused enum", "unused enums"],
+  class: ["class", "classes"],
+  slot: ["slot", "slots"],
+  schema: ["schema key", "schema keys"],
+  // `mixin: true` marks the class; `mixins: [M]` points at another one.
+  mixin: ["mixin class", "mixin classes"],
+  mixins: ["mixin", "mixins"],
+  pattern: ["pattern", "patterns"],
+  unit: ["unit", "units"]
+};
+var ENUM_KINDS = /* @__PURE__ */ new Set(["enum_detail"]);
+function formatDropped(dropped) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const entry of dropped) {
+    const group = groups.get(entry.kind);
+    if (group === void 0) groups.set(entry.kind, [entry]);
+    else group.push(entry);
+  }
+  const drops = [];
+  let renamed = "";
+  let inlined = "";
+  for (const [kind, entries] of groups) {
+    const phrase = phraseFor(kind, entries);
+    if (kind === "renamed") renamed = phrase;
+    else if (kind === "inlined") inlined = phrase;
+    else drops.push(phrase);
+  }
+  const sentences = [];
+  if (drops.length > 0) sentences.push(`Dropped: ${drops.join(", ")}.`);
+  if (renamed !== "") sentences.push(`Renamed: ${renamed}.`);
+  if (inlined !== "") sentences.push(`Inlined: ${inlined}.`);
+  return sentences.join(" ");
+}
+function phraseFor(kind, entries) {
+  const n = entries.length;
+  const counted = Object.hasOwn(COUNTED, kind) ? COUNTED[kind] : void 0;
+  if (counted !== void 0) return `${n} ${n === 1 ? counted[0] : counted[1]}`;
+  return `${kind} on ${n} ${nounFor(kind, entries)}`;
+}
+function nounFor(kind, entries) {
+  const one = entries.length === 1;
+  if (ENUM_KINDS.has(kind)) return one ? "enum" : "enums";
+  const slots = entries.filter((entry) => entry.element.includes(".")).length;
+  if (slots === entries.length) return one ? "slot" : "slots";
+  if (slots === 0) return one ? "class" : "classes";
+  return one ? "element" : "elements";
+}
+var capitalise2 = (text) => text.charAt(0).toUpperCase() + text.slice(1);
+var decapitalise = (text) => text.charAt(0).toLowerCase() + text.slice(1);
+var parts = (text) => text.split(/[^A-Za-z0-9]+/).filter((part) => part !== "");
+function toClassName(text) {
+  if (CLASS_NAME.test(text)) return text;
+  const name2 = parts(text).map(capitalise2).join("");
+  if (name2 === "") return "Class";
+  return CLASS_NAME.test(name2) ? name2 : `X${name2}`;
+}
+function toFieldName(text) {
+  if (FIELD_NAME.test(text)) return text;
+  const name2 = parts(text).map((part, i) => i === 0 ? decapitalise(part) : capitalise2(part)).join("");
+  if (name2 === "") return "field";
+  return FIELD_NAME.test(name2) ? name2 : `x${capitalise2(name2)}`;
+}
+function unique(base, taken) {
+  let name2 = base;
+  for (let n = 2; taken.has(name2); n++) name2 = `${base}${n}`;
+  taken.add(name2);
+  return name2;
+}
+var get = (record, key2) => Object.hasOwn(record, key2) ? record[key2] : void 0;
+function asRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+  return value;
+}
+var present = (value) => value !== void 0 && value !== null;
+function shown(value) {
+  if (Array.isArray(value)) return "a list";
+  if (typeof value === "object" && value !== null) return "a map";
+  return `\`${String(value)}\``;
+}
+function localName(mapping) {
+  let cut = -1;
+  for (const mark of [":", "/", "#"]) cut = Math.max(cut, mapping.lastIndexOf(mark));
+  return mapping.slice(cut + 1);
+}
+var stringOf = (value) => typeof value === "string" && value !== "" ? value : void 0;
+var stringList = (value) => Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+function annotationsOf(def) {
+  const out = /* @__PURE__ */ new Map();
+  const annotations = asRecord(get(def, "annotations"));
+  if (annotations === void 0) return out;
+  for (const tag of Object.keys(annotations)) {
+    const raw = get(annotations, tag);
+    const value = asRecord(raw) === void 0 ? raw : get(asRecord(raw) ?? {}, "value");
+    if (typeof value === "string" || typeof value === "boolean") out.set(tag, value);
+    else out.set(tag, String(value));
+  }
+  return out;
+}
+function slotKeysOf(def) {
+  const keys = Object.keys(asRecord(get(def, "attributes")) ?? {});
+  for (const slot of stringList(get(def, "slots"))) {
+    if (!keys.includes(slot)) keys.push(slot);
+  }
+  return keys;
+}
+function oneLine(text) {
+  if (text === void 0) return void 0;
+  const line = text.replace(/\s*[\r\n]+\s*/g, " ").trim();
+  return line === "" ? void 0 : line;
+}
+var list = (items) => items.map((item) => `\`${item}\``).join(", ");
+var at0 = (text) => ({ text, line: 0, col: 0, end: 0 });
+var stringType = (many) => ({
+  kind: "primitive",
+  name: "string",
+  written: at0("string"),
+  many
+});
+var schemaElement = (root) => stringOf(get(root, "name")) ?? "schema";
+var nothing = (element, detail) => ({
+  document: parse(""),
+  source: "",
+  dropped: [{ kind: "schema", element, detail }]
+});
+
+// src/import.ts
+import { parse as parseYAML } from "yaml";
+function importLinkML(text) {
+  let schema;
+  try {
+    schema = parseYAML(text);
+  } catch (error) {
+    return { output: "", dropped: [], diagnostics: [notYAML(error)] };
+  }
+  const { document, source, dropped } = fromLinkML(schema);
+  return { output: source, dropped, diagnostics: resolve(document).diagnostics };
+}
+function notYAML(error) {
+  const first = error instanceof Error ? error.message.split("\n")[0] ?? "" : String(error);
+  const detail = first.replace(/:$/, "");
+  return {
+    severity: "error",
+    code: "E_NOT_YAML",
+    message: `the input is not YAML: ${detail}`,
+    line: 1
+  };
+}
+
 // src/index.ts
-var VERSION = "0.2.1";
+var VERSION = "0.3.0";
 export {
   VERSION,
   compile,
   formatDiagnostic,
+  formatDropped,
+  fromLinkML,
+  importLinkML,
   parse,
   resolve,
   serialize,
   toLinkML,
-  toMermaid
+  toMermaid,
+  toSkiss
 };
 //# sourceMappingURL=index.js.map