@atproto/api 0.6.16 → 0.6.18

package/dist/rich-text/rich-text.d.ts

@@ -4,6 +4,7 @@ import { UnicodeString } from './unicode';
 export declare type Facet = AppBskyRichtextFacet.Main;
 export declare type FacetLink = AppBskyRichtextFacet.Link;
 export declare type FacetMention = AppBskyRichtextFacet.Mention;
+export declare type FacetTag = AppBskyRichtextFacet.Tag;
 export declare type Entity = AppBskyFeedPost.Entity;
 export interface RichTextProps {
     text: string;
@@ -21,6 +22,8 @@ export declare class RichTextSegment {
     isLink(): boolean;
     get mention(): FacetMention | undefined;
     isMention(): boolean;
+    get tag(): FacetTag | undefined;
+    isTag(): boolean;
 }
 export declare class RichText {
     unicodeText: UnicodeString;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atproto/api",
-  "version": "0.6.16",
+  "version": "0.6.18",
   "license": "MIT",
   "description": "Client library for atproto and Bluesky",
   "keywords": [
@@ -27,7 +27,7 @@
   "devDependencies": {
     "common-tags": "^1.8.2",
     "@atproto/lex-cli": "^0.2.1",
-    "@atproto/pds": "^0.1.16"
+    "@atproto/pds": "^0.1.18"
   },
   "scripts": {
     "codegen": "pnpm docgen && node ./scripts/generate-code.mjs && lex gen-api ./src/client ../../lexicons/com/atproto/*/* ../../lexicons/app/bsky/*/*",

package/src/client/lexicons.ts

@@ -5622,6 +5622,16 @@ export const schemaDict = {
               type: 'union',
               refs: ['lex:com.atproto.label.defs#selfLabels'],
             },
+            tags: {
+              type: 'array',
+              maxLength: 8,
+              items: {
+                type: 'string',
+                maxLength: 640,
+                maxGraphemes: 64,
+              },
+              description: 'Additional non-inline tags describing this post.',
+            },
             createdAt: {
               type: 'string',
               format: 'datetime',
@@ -6761,6 +6771,7 @@ export const schemaDict = {
               refs: [
                 'lex:app.bsky.richtext.facet#mention',
                 'lex:app.bsky.richtext.facet#link',
+                'lex:app.bsky.richtext.facet#tag',
               ],
             },
           },
@@ -6788,6 +6799,18 @@ export const schemaDict = {
           },
         },
       },
+      tag: {
+        type: 'object',
+        description: 'A hashtag.',
+        required: ['tag'],
+        properties: {
+          tag: {
+            type: 'string',
+            maxLength: 640,
+            maxGraphemes: 64,
+          },
+        },
+      },
       byteSlice: {
         type: 'object',
         description:

package/src/client/types/app/bsky/feed/post.ts

@@ -29,6 +29,8 @@ export interface Record {
   labels?:
     | ComAtprotoLabelDefs.SelfLabels
     | { $type: string; [k: string]: unknown }
+  /** Additional non-inline tags describing this post. */
+  tags?: string[]
   createdAt: string
   [k: string]: unknown
 }

package/src/client/types/app/bsky/richtext/facet.ts

@@ -8,7 +8,7 @@ import { CID } from 'multiformats/cid'
 
 export interface Main {
   index: ByteSlice
-  features: (Mention | Link | { $type: string; [k: string]: unknown })[]
+  features: (Mention | Link | Tag | { $type: string; [k: string]: unknown })[]
   [k: string]: unknown
 }
 
@@ -61,6 +61,22 @@ export function validateLink(v: unknown): ValidationResult {
   return lexicons.validate('app.bsky.richtext.facet#link', v)
 }
 
+/** A hashtag. */
+export interface Tag {
+  tag: string
+  [k: string]: unknown
+}
+
+export function isTag(v: unknown): v is Tag {
+  return (
+    isObj(v) && hasProp(v, '$type') && v.$type === 'app.bsky.richtext.facet#tag'
+  )
+}
+
+export function validateTag(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.richtext.facet#tag', v)
+}
+
 /** A text segment. Start is inclusive, end is exclusive. Indices are for utf8-encoded strings. */
 export interface ByteSlice {
   byteStart: number

package/src/rich-text/detection.ts

@@ -69,6 +69,33 @@ export function detectFacets(text: UnicodeString): Facet[] | undefined {
       })
     }
   }
+  {
+    const re = /(?:^|\s)(#[^\d\s]\S*)(?=\s)?/g
+    while ((match = re.exec(text.utf16))) {
+      let [tag] = match
+      const hasLeadingSpace = /^\s/.test(tag)
+
+      tag = tag.trim().replace(/\p{P}+$/gu, '') // strip ending punctuation
+
+      // inclusive of #, max of 64 chars
+      if (tag.length > 66) continue
+
+      const index = match.index + (hasLeadingSpace ? 1 : 0)
+
+      facets.push({
+        index: {
+          byteStart: text.utf16IndexToUtf8Index(index),
+          byteEnd: text.utf16IndexToUtf8Index(index + tag.length), // inclusive of last char
+        },
+        features: [
+          {
+            $type: 'app.bsky.richtext.facet#tag',
+            tag,
+          },
+        ],
+      })
+    }
+  }
   return facets.length > 0 ? facets : undefined
 }
 

package/src/rich-text/rich-text.ts

@@ -100,6 +100,7 @@ import { detectFacets } from './detection'
 export type Facet = AppBskyRichtextFacet.Main
 export type FacetLink = AppBskyRichtextFacet.Link
 export type FacetMention = AppBskyRichtextFacet.Mention
+export type FacetTag = AppBskyRichtextFacet.Tag
 export type Entity = AppBskyFeedPost.Entity
 
 export interface RichTextProps {
@@ -141,6 +142,18 @@ export class RichTextSegment {
   isMention() {
     return !!this.mention
   }
+
+  get tag(): FacetTag | undefined {
+    const tag = this.facet?.features.find(AppBskyRichtextFacet.isTag)
+    if (AppBskyRichtextFacet.isTag(tag)) {
+      return tag
+    }
+    return undefined
+  }
+
+  isTag() {
+    return !!this.tag
+  }
 }
 
 export class RichText {

package/tests/agent.test.ts

@@ -197,7 +197,7 @@ describe('agent', () => {
 
     // put the agent through the auth flow
     AtpAgent.configure({ fetch: tokenExpiredFetchHandler })
-    const res1 = await agent.api.app.bsky.feed.getTimeline()
+    const res1 = await createPost(agent)
     AtpAgent.configure({ fetch: defaultFetchHandler })
 
     expect(res1.success).toEqual(true)
@@ -267,9 +267,9 @@ describe('agent', () => {
     // put the agent through the auth flow
     AtpAgent.configure({ fetch: tokenExpiredFetchHandler })
     const [res1, res2, res3] = await Promise.all([
-      agent.api.app.bsky.feed.getTimeline(),
-      agent.api.app.bsky.feed.getTimeline(),
-      agent.api.app.bsky.feed.getTimeline(),
+      createPost(agent),
+      createPost(agent),
+      createPost(agent),
     ])
     AtpAgent.configure({ fetch: defaultFetchHandler })
 
@@ -462,3 +462,14 @@ describe('agent', () => {
     })
   })
 })
+
+const createPost = async (agent: AtpAgent) => {
+  return agent.api.com.atproto.repo.createRecord({
+    repo: agent.session?.did ?? '',
+    collection: 'app.bsky.feed.post',
+    record: {
+      text: 'hello there',
+      createdAt: new Date().toISOString(),
+    },
+  })
+}

package/tests/bsky-agent.test.ts

@@ -20,6 +20,20 @@ describe('agent', () => {
     await close()
   })
 
+  const getProfileDisplayName = async (
+    agent: BskyAgent,
+  ): Promise<string | undefined> => {
+    try {
+      const res = await agent.api.app.bsky.actor.profile.get({
+        repo: agent.session?.did || '',
+        rkey: 'self',
+      })
+      return res.value.displayName ?? ''
+    } catch (err) {
+      return undefined
+    }
+  }
+
   it('upsertProfile correctly creates and updates profiles.', async () => {
     const agent = new BskyAgent({ service: server.url })
 
@@ -28,9 +42,8 @@ describe('agent', () => {
       email: 'user1@test.com',
       password: 'password',
     })
-
-    const profile1 = await agent.getProfile({ actor: agent.session?.did || '' })
-    expect(profile1.data.displayName).toBeFalsy()
+    const displayName1 = await getProfileDisplayName(agent)
+    expect(displayName1).toBeFalsy()
 
     await agent.upsertProfile((existing) => {
       expect(existing).toBeFalsy()
@@ -39,8 +52,8 @@ describe('agent', () => {
       }
     })
 
-    const profile2 = await agent.getProfile({ actor: agent.session?.did || '' })
-    expect(profile2.data.displayName).toBe('Bob')
+    const displayName2 = await getProfileDisplayName(agent)
+    expect(displayName2).toBe('Bob')
 
     await agent.upsertProfile((existing) => {
       expect(existing).toBeTruthy()
@@ -49,8 +62,8 @@ describe('agent', () => {
       }
     })
 
-    const profile3 = await agent.getProfile({ actor: agent.session?.did || '' })
-    expect(profile3.data.displayName).toBe('BOB')
+    const displayName3 = await getProfileDisplayName(agent)
+    expect(displayName3).toBe('BOB')
   })
 
   it('upsertProfile correctly handles CAS failures.', async () => {
@@ -62,8 +75,8 @@ describe('agent', () => {
       password: 'password',
     })
 
-    const profile1 = await agent.getProfile({ actor: agent.session?.did || '' })
-    expect(profile1.data.displayName).toBeFalsy()
+    const displayName1 = await getProfileDisplayName(agent)
+    expect(displayName1).toBeFalsy()
 
     let hasConflicted = false
     let ranTwice = false
@@ -88,8 +101,8 @@ describe('agent', () => {
     })
     expect(ranTwice).toBe(true)
 
-    const profile2 = await agent.getProfile({ actor: agent.session?.did || '' })
-    expect(profile2.data.displayName).toBe('Bob')
+    const displayName2 = await getProfileDisplayName(agent)
+    expect(displayName2).toBe('Bob')
   })
 
   it('upsertProfile wont endlessly retry CAS failures.', async () => {
@@ -101,8 +114,8 @@ describe('agent', () => {
       password: 'password',
     })
 
-    const profile1 = await agent.getProfile({ actor: agent.session?.did || '' })
-    expect(profile1.data.displayName).toBeFalsy()
+    const displayName1 = await getProfileDisplayName(agent)
+    expect(displayName1).toBeFalsy()
 
     const p = agent.upsertProfile(async (_existing) => {
       await agent.com.atproto.repo.putRecord({

package/tests/rich-text-detection.test.ts

@@ -1,4 +1,5 @@
 import { AtpAgent, RichText, RichTextSegment } from '../src'
+import { isTag } from '../src/client/types/app/bsky/richtext/facet'
 
 describe('detectFacets', () => {
   const agent = new AtpAgent({ service: 'http://localhost' })
@@ -208,6 +209,109 @@ describe('detectFacets', () => {
       expect(Array.from(rt.segments(), segmentToOutput)).toEqual(outputs[i])
     }
   })
+
+  it('correctly detects tags inline', async () => {
+    const inputs: [
+      string,
+      string[],
+      { byteStart: number; byteEnd: number }[],
+    ][] = [
+      ['#a', ['#a'], [{ byteStart: 0, byteEnd: 2 }]],
+      [
+        '#a #b',
+        ['#a', '#b'],
+        [
+          { byteStart: 0, byteEnd: 2 },
+          { byteStart: 3, byteEnd: 5 },
+        ],
+      ],
+      ['#1', [], []],
+      ['#tag', ['#tag'], [{ byteStart: 0, byteEnd: 4 }]],
+      ['body #tag', ['#tag'], [{ byteStart: 5, byteEnd: 9 }]],
+      ['#tag body', ['#tag'], [{ byteStart: 0, byteEnd: 4 }]],
+      ['body #tag body', ['#tag'], [{ byteStart: 5, byteEnd: 9 }]],
+      ['body #1', [], []],
+      ['body #a1', ['#a1'], [{ byteStart: 5, byteEnd: 8 }]],
+      ['#', [], []],
+      ['text #', [], []],
+      ['text # text', [], []],
+      [
+        'body #thisisa64characterstring_aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+        ['#thisisa64characterstring_aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'],
+        [{ byteStart: 5, byteEnd: 71 }],
+      ],
+      [
+        'body #thisisa65characterstring_aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab',
+        [],
+        [],
+      ],
+      [
+        'its a #double#rainbow',
+        ['#double#rainbow'],
+        [{ byteStart: 6, byteEnd: 21 }],
+      ],
+      ['##hashash', ['##hashash'], [{ byteStart: 0, byteEnd: 9 }]],
+      ['some #n0n3s@n5e!', ['#n0n3s@n5e'], [{ byteStart: 5, byteEnd: 15 }]],
+      [
+        'works #with,punctuation',
+        ['#with,punctuation'],
+        [{ byteStart: 6, byteEnd: 23 }],
+      ],
+      [
+        'strips trailing #punctuation, #like. #this!',
+        ['#punctuation', '#like', '#this'],
+        [
+          { byteStart: 16, byteEnd: 28 },
+          { byteStart: 30, byteEnd: 35 },
+          { byteStart: 37, byteEnd: 42 },
+        ],
+      ],
+      [
+        'strips #multi_trailing___...',
+        ['#multi_trailing'],
+        [{ byteStart: 7, byteEnd: 22 }],
+      ],
+      [
+        'works with #🦋 emoji, and #butter🦋fly',
+        ['#🦋', '#butter🦋fly'],
+        [
+          { byteStart: 11, byteEnd: 16 },
+          { byteStart: 28, byteEnd: 42 },
+        ],
+      ],
+      [
+        '#same #same #but #diff',
+        ['#same', '#same', '#but', '#diff'],
+        [
+          { byteStart: 0, byteEnd: 5 },
+          { byteStart: 6, byteEnd: 11 },
+          { byteStart: 12, byteEnd: 16 },
+          { byteStart: 17, byteEnd: 22 },
+        ],
+      ],
+    ]
+
+    for (const [input, tags, indices] of inputs) {
+      const rt = new RichText({ text: input })
+      await rt.detectFacets(agent)
+
+      let detectedTags: string[] = []
+      let detectedIndices: { byteStart: number; byteEnd: number }[] = []
+
+      for (const { facet } of rt.segments()) {
+        if (!facet) continue
+        for (const feature of facet.features) {
+          if (isTag(feature)) {
+            detectedTags.push(feature.tag)
+          }
+        }
+        detectedIndices.push(facet.index)
+      }
+
+      expect(detectedTags).toEqual(tags)
+      expect(detectedIndices).toEqual(indices)
+    }
+  })
 })
 
 function segmentToOutput(segment: RichTextSegment): string[] {