@atlaskit/adf-schema 28.1.11 → 28.1.13

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @atlaskit/adf-schema
 
+## 28.1.13
+
+### Patch Changes
+
+- 7999d27: Add src to npmignore
+
+## 28.1.12
+
+### Patch Changes
+
+- d20f097: Return index to npmignore
+
 ## 28.1.11
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaskit/adf-schema",
-  "version": "28.1.11",
+  "version": "28.1.13",
   "description": "Shared package that contains the ADF-schema (json) and ProseMirror node/mark specs",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"

package/build/tsconfig.json

@@ -1,18 +0,0 @@
-{
-  "extends": "../tsconfig",
-  "compilerOptions": {
-    "declaration": true,
-    "target": "es5",
-    "paths": {}
-  },
-  "include": [
-    "../src/**/*.ts",
-    "../src/**/*.tsx"
-  ],
-  "exclude": [
-    "../src/**/__tests__/*",
-    "../src/**/*.test.*",
-    "../src/**/test.*",
-    "../src/json-schema"
-  ]
-}

package/index.ts

@@ -1,275 +0,0 @@
-//
-// This file is used in development to resolve types for the package (because they live in `src/`)
-// *without* needing to use the `types` `package.json` field.
-//
-// We don't want to use the `types` field, as we want to point it to the declaration file in the
-// published package.
-//
-// This file should be npm-ignored, so that it doesn't exist in the published package, and resolution
-// falls through to the `types` and `main` `package.json` fields.
-//
-export {
-  AnnotationTypes,
-  B100,
-  B400,
-  B50,
-  B500,
-  B75,
-  G200,
-  G300,
-  G400,
-  G50,
-  G500,
-  G75,
-  N0,
-  N20,
-  N200,
-  N30,
-  N300,
-  N40,
-  N50,
-  N500,
-  N60,
-  N80,
-  N800,
-  N90,
-  P100,
-  P300,
-  P400,
-  P50,
-  P500,
-  P75,
-  PanelType,
-  R100,
-  R300,
-  R400,
-  R50,
-  R500,
-  R75,
-  T100,
-  T300,
-  T50,
-  T500,
-  T75,
-  Y200,
-  Y400,
-  Y50,
-  Y500,
-  Y75,
-  acNameToEmoji,
-  acShortcutToEmoji,
-  alignment,
-  alignmentPositionMap,
-  annotation,
-  blockCard,
-  blockquote,
-  bodiedExtension,
-  breakout,
-  bulletList,
-  bulletListSelector,
-  code,
-  codeBlock,
-  codeBlockToJSON,
-  colorPalette,
-  /** @deprecated [ED-15849] The extended palette is now rolled into the main one. Use `colorPalette` instead. */
-  colorPaletteExtended,
-  confluenceInlineComment,
-  confluenceJiraIssue,
-  confluenceUnsupportedBlock,
-  confluenceUnsupportedInline,
-  copyPrivateMediaAttributes,
-  createSchema,
-  dataConsumer,
-  date,
-  decisionItem,
-  decisionList,
-  decisionListSelector,
-  doc,
-  em,
-  emoji,
-  emojiIdToAcName,
-  expand,
-  expandToJSON,
-  extension,
-  generateUuid,
-  getEmojiAcName,
-  getLinkMatch,
-  hardBreak,
-  heading,
-  hexToRgb,
-  hexToRgba,
-  image,
-  indentation,
-  inlineCard,
-  inlineExtension,
-  inlineNodes,
-  isHex,
-  isRgb,
-  isSafeUrl,
-  layoutColumn,
-  layoutSection,
-  link,
-  linkify,
-  linkifyMatch,
-  linkToJSON,
-  listItem,
-  media,
-  mediaGroup,
-  mediaSingle,
-  mediaSingleToJSON,
-  mediaToJSON,
-  mention,
-  mentionToJSON,
-  nestedExpand,
-  normalizeHexColor,
-  normalizeUrl,
-  orderedList,
-  orderedListSelector,
-  panel,
-  paragraph,
-  placeholder,
-  rgbToHex,
-  rule,
-  sanitizeNodes,
-  getCellDomAttrs,
-  status,
-  strike,
-  strong,
-  subsup,
-  table,
-  tableWithCustomWidth,
-  tableBackgroundBorderColor,
-  tableBackgroundColorNames,
-  tableBackgroundColorPalette,
-  tableCell,
-  tableCellContentDomSelector,
-  tableCellContentWrapperSelector,
-  tableCellSelector,
-  tableHeader,
-  tableHeaderSelector,
-  tablePrefixSelector,
-  tableRow,
-  tableToJSON,
-  taskItem,
-  taskList,
-  taskListSelector,
-  text,
-  textColor,
-  toJSONTableCell,
-  toJSONTableHeader,
-  typeAheadQuery,
-  underline,
-  unknownBlock,
-  unsupportedBlock,
-  unsupportedInline,
-  unsupportedNodeTypesForMediaCards,
-  uuid,
-  buildAnnotationMarkDataAttributes,
-  AnnotationMarkStates,
-  border,
-  borderColorPalette,
-} from './src';
-export type {
-  AlignmentAttributes,
-  AlignmentMarkDefinition,
-  AnnotationMarkAttributes,
-  AnnotationMarkDefinition,
-  BlockCardDefinition,
-  BlockContent,
-  BlockQuoteDefinition,
-  BodiedExtensionDefinition,
-  BreakoutMarkAttrs,
-  BreakoutMarkDefinition,
-  BulletListDefinition,
-  CardAttributes,
-  CellAttributes,
-  CodeBlockAttrs,
-  CodeBlockBaseDefinition,
-  CodeBlockDefinition,
-  CodeBlockWithMarksDefinition,
-  CodeDefinition,
-  DataConsumerAttributes,
-  DataConsumerDefinition,
-  DataType,
-  DateDefinition,
-  DecisionItemDefinition,
-  DecisionListDefinition,
-  DocNode,
-  EmDefinition,
-  EmojiAttributes,
-  EmojiDefinition,
-  ExpandDefinition,
-  ExtensionDefinition,
-  ExtensionLayout,
-  ExternalMediaAttributes,
-  HardBreakDefinition,
-  HeadingBaseDefinition,
-  HeadingDefinition,
-  HeadingWithAlignmentDefinition,
-  HeadingWithIndentationDefinition,
-  HeadingWithMarksDefinition,
-  IndentationMarkAttributes,
-  IndentationMarkDefinition,
-  Inline,
-  InlineAtomic,
-  InlineCardDefinition,
-  InlineCode,
-  InlineExtensionDefinition,
-  InlineFormattedText,
-  InlineLinkText,
-  LayoutColumnDefinition,
-  LayoutSectionDefinition,
-  LinkAttributes,
-  LinkDefinition,
-  ListItemArray,
-  ListItemDefinition,
-  MarksObject,
-  Match,
-  MediaADFAttrs,
-  MediaAttributes,
-  MediaBaseAttributes,
-  MediaDefinition,
-  MediaDisplayType,
-  MediaGroupDefinition,
-  MediaSingleDefinition,
-  MediaType,
-  MentionAttributes,
-  MentionDefinition,
-  MentionUserType,
-  NameToEmoji,
-  NestedExpandContent,
-  NestedExpandDefinition,
-  NoMark,
-  OrderedListDefinition,
-  PanelAttributes,
-  PanelDefinition,
-  ParagraphBaseDefinition,
-  ParagraphDefinition,
-  ParagraphWithAlignmentDefinition,
-  ParagraphWithIndentationDefinition,
-  ParagraphWithMarksDefinition,
-  PlaceholderDefinition,
-  RuleDefinition,
-  StatusDefinition,
-  StrikeDefinition,
-  StrongDefinition,
-  SubSupAttributes,
-  SubSupDefinition,
-  TableAttributes,
-  TableCellDefinition,
-  TableDefinition,
-  TableHeaderDefinition,
-  TableLayout,
-  TableRowDefinition,
-  TaskItemDefinition,
-  TaskListContent,
-  TaskListDefinition,
-  TextColorAttributes,
-  TextColorDefinition,
-  TextDefinition,
-  UnderlineDefinition,
-  UrlType,
-  AnnotationId,
-  BorderMarkAttributes,
-  BorderMarkDefinition,
-} from './src';

package/src/__tests__/unit/json-schema/v1.ts

@@ -1,55 +0,0 @@
-import { initialize } from 'adf-test-helpers/src/ajv';
-
-import v1SchemaFull from '../../../../json-schema/v1/full.json';
-import v1SchemaStage0 from '../../../../json-schema/v1/stage-0.json';
-
-import {
-  fullValidJsonSchema,
-  fullInvalidJsonSchema,
-  stage0ValidJsonSchema,
-  stage0InvalidJsonSchema,
-} from '@atlassian/adf-schema-json';
-
-const ajv = initialize();
-const packageName = process.env._PACKAGE_NAME_ as string;
-
-describe(`${packageName} json-schema v1`, () => {
-  const validateFull = ajv.compile(v1SchemaFull);
-  const validateStage0 = ajv.compile(v1SchemaStage0);
-
-  describe('full', () => {
-    for (const file of fullValidJsonSchema) {
-      it(`validates '${file.name}'`, () => {
-        validateFull(file.data);
-        expect(validateFull.errors).toEqual(null);
-        // Valid `full` use cases should be valid against `stage-0` schema
-        validateStage0(file.data);
-        expect(validateStage0.errors).toEqual(null);
-      });
-    }
-
-    for (const file of fullInvalidJsonSchema) {
-      it(`does not validate '${file.name}'`, () => {
-        expect(validateFull(file.data)).toEqual(false);
-      });
-    }
-  });
-
-  describe('stage-0', () => {
-    for (const file of stage0ValidJsonSchema) {
-      it(`validates '${file.name}'`, () => {
-        validateStage0(file.data);
-        expect(validateStage0.errors).toEqual(null);
-
-        // Valid `stage-0` use cases should be invalid against `full` schema
-        expect(validateFull(file.data)).toEqual(false);
-      });
-    }
-
-    for (const file of stage0InvalidJsonSchema) {
-      it(`does not validate '${file.name}'`, () => {
-        expect(validateStage0(file.data)).toEqual(false);
-      });
-    }
-  });
-});

package/src/__tests__/unit/schema/create-schema.ts

@@ -1,214 +0,0 @@
-const packageName = process.env._PACKAGE_NAME_ as string;
-import { code as codeBase, createSchema, sanitizeNodes } from '../../..';
-import { sanitizeNodeSpecContent } from '../../../schema/create-schema';
-const filterGroupDecMark = (marks: Array<string>) =>
-  marks.filter((mark) => mark[0] !== '_' || mark[1] !== '_');
-
-describe(`${packageName}/schema createSchema helper`, () => {
-  it('should add only defined marks and nodes to the schema', () => {
-    const nodesConfig = ['doc', 'paragraph', 'text'];
-    const marksConfig = ['em', 'strong', 'strike'];
-    const schema = createSchema({ nodes: nodesConfig, marks: marksConfig });
-    const nodes = Object.keys(schema.nodes);
-    const marks = filterGroupDecMark(Object.keys(schema.marks));
-    expect(nodes).toEqual(['doc', 'paragraph', 'text']);
-    expect(marks).toEqual(['em', 'strong', 'strike']);
-  });
-
-  it('should preserv order for marks and nodes in the schema', () => {
-    const nodesConfig = ['text', 'doc', 'paragraph'];
-    const marksConfig = ['strong', 'strike', 'em'];
-    const schema = createSchema({ nodes: nodesConfig, marks: marksConfig });
-    const nodes = Object.keys(schema.nodes);
-    const marks = filterGroupDecMark(Object.keys(schema.marks));
-    expect(nodes).toEqual(['doc', 'paragraph', 'text']);
-    expect(marks).toEqual(['em', 'strong', 'strike']);
-  });
-
-  it('should allow custom node spec for built-in node type', () => {
-    const listItem = {
-      content: 'paragraph block*',
-      parseDOM: [{ tag: 'div' }],
-    };
-    const nodesConfig = ['doc', 'paragraph', 'text'];
-    const schema = createSchema({
-      nodes: nodesConfig,
-      customNodeSpecs: { listItem },
-    });
-    const nodes = Object.keys(schema.nodes);
-    expect(nodes).toEqual(['doc', 'paragraph', 'text', 'listItem']);
-    expect(schema.nodes.listItem.spec).toEqual(listItem);
-  });
-
-  it('should allow custom node spec', () => {
-    const jiraIssue = {
-      content: 'paragraph block*',
-      parseDOM: [{ tag: 'div' }],
-    };
-    const nodesConfig = ['doc', 'paragraph', 'text'];
-    const schema = createSchema({
-      nodes: nodesConfig,
-      customNodeSpecs: { jiraIssue },
-    });
-    const nodes = Object.keys(schema.nodes);
-    expect(nodes).toEqual(['doc', 'paragraph', 'text', 'jiraIssue']);
-  });
-
-  it('should allow custom mark spec for built-in mark type', () => {
-    const code = { ...codeBase, excludes: 'em' };
-    const nodesConfig = ['doc', 'paragraph', 'text'];
-    const marksConfig = ['em'];
-    const schema = createSchema({
-      nodes: nodesConfig,
-      marks: marksConfig,
-      customMarkSpecs: { code },
-    });
-    const marks = filterGroupDecMark(Object.keys(schema.marks));
-    expect(marks).toEqual(['em', 'code']);
-    expect(schema.marks.code.spec).toEqual(code);
-  });
-
-  it('should allow custom mark spec', () => {
-    const monospace = { ...codeBase, excludes: 'em' };
-    const nodesConfig = ['doc', 'paragraph', 'text'];
-    const marksConfig = ['em'];
-    const schema = createSchema({
-      nodes: nodesConfig,
-      marks: marksConfig,
-      customMarkSpecs: { monospace },
-    });
-    const marks = filterGroupDecMark(Object.keys(schema.marks));
-    expect(marks).toEqual(['em', 'monospace']);
-    expect(schema.marks.monospace.spec).toEqual(monospace);
-  });
-
-  it('should allow only custom mark spec', () => {
-    const code = { ...codeBase, excludes: '' };
-    const nodesConfig = ['doc', 'paragraph', 'text'];
-    const schema = createSchema({
-      nodes: nodesConfig,
-      customMarkSpecs: { code },
-    });
-    expect(schema.marks.code.spec).toEqual(code);
-  });
-
-  describe('fixNodeContentSchema', () => {
-    it('excludes unsupported nodes in node content', () => {
-      const nodes = {
-        node1: {
-          content: 'node1 | nodeDoesNotExist | node2 | anotherNodeDoesNotExist',
-        },
-        node2: {
-          content: 'node2',
-        },
-      };
-      const sanitizedNodes = sanitizeNodes(nodes, {});
-
-      expect(sanitizedNodes).toEqual({
-        node1: {
-          content: 'node1 | node2',
-        },
-        node2: {
-          content: 'node2',
-        },
-      });
-    });
-
-    it('excludes unsupported nodes in node content - 2', () => {
-      const nodes = {
-        node1: {
-          content:
-            '(node1 | nodeDoesNotExist | anotherNodeDoesNotExist | node2)*',
-        },
-        node2: {
-          content: 'node2',
-        },
-      };
-      const sanitizedNodes = sanitizeNodes(nodes, {});
-
-      expect(sanitizedNodes).toEqual({
-        node1: {
-          content: '(node1 | node2)*',
-        },
-        node2: {
-          content: 'node2',
-        },
-      });
-    });
-
-    it('does not generate invalid content', () => {
-      const nodes = {
-        node1: {
-          content: 'nodeDoesNotExist | anotherNodeDoesNotExist',
-        },
-        node2: {
-          content: 'node2 | nodeDoesNotExist',
-        },
-      };
-      const sanitizedNodes = sanitizeNodes(nodes, {});
-
-      expect(sanitizedNodes).toEqual({
-        node1: {
-          content: '',
-        },
-        node2: {
-          content: 'node2',
-        },
-      });
-    });
-
-    it('should remove unsupported block from content', () => {
-      const nodes = {
-        node1: {
-          content: '(node2 | unsupportedBlock){2,3} unsupportedBlock*',
-        },
-        node2: { content: 'node2' },
-      };
-      const content = '(node2 | unsupportedBlock){2,3} unsupportedBlock*';
-      expect(sanitizeNodeSpecContent(nodes, content)).toEqual('(node2 ){2,3}');
-    });
-
-    it('modifies node immutably', () => {
-      const nodeSpec = {
-        content: 'nodeDoesNotExist',
-      };
-      const nodes = {
-        node: nodeSpec,
-      };
-      const sanitizedNodes = sanitizeNodes(nodes, {});
-
-      expect(sanitizedNodes).toEqual({
-        node: {
-          content: '',
-        },
-      });
-
-      expect(nodeSpec).toEqual({
-        content: 'nodeDoesNotExist',
-      });
-    });
-
-    it('recognizes node from group', () => {
-      const nodes = {
-        node1: {
-          content: 'inline+',
-          group: 'block',
-        },
-        node2: {
-          group: 'inline',
-        },
-      };
-      const sanitizedNodes = sanitizeNodes(nodes, {});
-
-      expect(sanitizedNodes).toEqual({
-        node1: {
-          content: 'inline+',
-          group: 'block',
-        },
-        node2: {
-          group: 'inline',
-        },
-      });
-    });
-  });
-});